From 1f2625e9a4b5f429a04121539a9c3ec94c745e81 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:38:17 +0200 Subject: [PATCH 01/86] initialize gateway --- contracts/prototypes/Gateway.sol | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 contracts/prototypes/Gateway.sol diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol new file mode 100644 index 00000000..4f9e3bbd --- /dev/null +++ b/contracts/prototypes/Gateway.sol @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +contract Gateway { + event Forwarded(address indexed destination, uint256 value, bytes data); + + function forwardCall(address destination, bytes calldata data) external payable returns (bytes memory) { + (bool success, bytes memory result) = destination.call{value: msg.value}(data); + + require(success, "Call failed"); + + emit Forwarded(destination, msg.value, data); + + return result; + } +} \ No newline at end of file From bd7100791ccbbe3d724e8cd5ffb90aed8ee1b124 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:39:48 +0200 Subject: [PATCH 02/86] add receiver example --- contracts/prototypes/Receiver.sol | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 contracts/prototypes/Receiver.sol diff --git a/contracts/prototypes/Receiver.sol b/contracts/prototypes/Receiver.sol new file mode 100644 index 00000000..8a49d710 --- /dev/null +++ b/contracts/prototypes/Receiver.sol @@ -0,0 +1,15 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +contract Receiver { + event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); + event ReceivedB(address sender, uint256 value, string[] strs, uint256[] nums, bool flag); + + function receiveA(string memory str, uint256 num, bool flag) external payable { + emit ReceivedA(msg.sender, msg.value, str, num, flag); + } + + function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external payable { + emit ReceivedB(msg.sender, msg.value, strs, nums, flag); + } +} \ No newline at end of file From 3553a8fe0750c58fad408176a17f198ef83d90aa Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:40:07 +0200 Subject: [PATCH 03/86] add test examples --- test/prototypes/GatewayIntegration.spec.ts | 52 ++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100644 test/prototypes/GatewayIntegration.spec.ts diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts new file mode 100644 index 00000000..03d111a7 --- /dev/null +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -0,0 +1,52 @@ +import { expect } from "chai"; +import { ethers } from "hardhat"; +import { Contract } from "ethers"; + +describe("Gateway and Receiver", function () { + let receiver: Contract; + let gateway: Contract; + let owner: any, addr1: any; + + beforeEach(async function () { + // Get the ContractFactories and Signers + const Receiver = await ethers.getContractFactory("Receiver"); + const Gateway = await ethers.getContractFactory("Gateway"); + [owner, addr1] = await ethers.getSigners(); + + // Deploy the contracts + receiver = await Receiver.deploy(); + gateway = await Gateway.deploy(); + }); + + it("should forward call to Receiver's receiveA function", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data + const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); + + // Call forwardCall on the Gateway contract + const tx = await gateway.forwardCall(receiver.address, data, { value: value }); + await tx.wait(); + + // Listen for the event + await expect(tx) + .to.emit(receiver, "ReceivedA") + .withArgs(gateway.address, value, str, num, flag); + }); + + it("should forward call to Receiver's receiveB function", async function () { + const strs = ["Hello", "Hardhat"]; + const nums = [1, 2, 3]; + const flag = false; + const value = ethers.utils.parseEther("0.5"); + const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); + const tx = await gateway.forwardCall(receiver.address, data, { value: value }); + await tx.wait(); + await expect(tx) + .to.emit(receiver, "ReceivedB") + .withArgs(gateway.address, value, strs, nums, flag); + }); +}); \ No newline at end of file From 791834b3e27c6d557faa9c5c037a92fb3eeb642d Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:40:31 +0200 Subject: [PATCH 04/86] add entry for test prototype --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index fd5ea6a7..fb5697be 100644 --- a/package.json +++ b/package.json @@ -78,6 +78,7 @@ "lint:fix": "npx eslint . --ext .js,.ts,.json --fix", "prepublishOnly": "yarn build", "test": "yarn compile && npx hardhat test", + "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch" }, "types": "./dist/lib/index.d.ts", From c1bd47df72b3fe292d82e234f85418e16cc96462 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:40:51 +0200 Subject: [PATCH 05/86] typechain --- typechain-types/contracts/index.ts | 2 + .../contracts/prototypes/Gateway.ts | 141 +++++++++++ .../contracts/prototypes/Receiver.ts | 232 ++++++++++++++++++ typechain-types/contracts/prototypes/index.ts | 5 + typechain-types/factories/contracts/index.ts | 1 + .../contracts/prototypes/Gateway__factory.ts | 112 +++++++++ .../contracts/prototypes/Receiver__factory.ts | 183 ++++++++++++++ .../factories/contracts/prototypes/index.ts | 5 + typechain-types/hardhat.d.ts | 18 ++ typechain-types/index.ts | 4 + 10 files changed, 703 insertions(+) create mode 100644 typechain-types/contracts/prototypes/Gateway.ts create mode 100644 typechain-types/contracts/prototypes/Receiver.ts create mode 100644 typechain-types/contracts/prototypes/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/Gateway__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/Receiver__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/index.ts diff --git a/typechain-types/contracts/index.ts b/typechain-types/contracts/index.ts index 9efb820b..6fa2e250 100644 --- a/typechain-types/contracts/index.ts +++ b/typechain-types/contracts/index.ts @@ -3,5 +3,7 @@ /* eslint-disable */ import type * as evm from "./evm"; export type { evm }; +import type * as prototypes from "./prototypes"; +export type { prototypes }; import type * as zevm from "./zevm"; export type { zevm }; diff --git a/typechain-types/contracts/prototypes/Gateway.ts b/typechain-types/contracts/prototypes/Gateway.ts new file mode 100644 index 00000000..5411e94d --- /dev/null +++ b/typechain-types/contracts/prototypes/Gateway.ts @@ -0,0 +1,141 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface GatewayInterface extends utils.Interface { + functions: { + "forwardCall(address,bytes)": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "forwardCall"): FunctionFragment; + + encodeFunctionData( + functionFragment: "forwardCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult( + functionFragment: "forwardCall", + data: BytesLike + ): Result; + + events: { + "Forwarded(address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Forwarded"): EventFragment; +} + +export interface ForwardedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ForwardedEvent = TypedEvent< + [string, BigNumber, string], + ForwardedEventObject +>; + +export type ForwardedEventFilter = TypedEventFilter; + +export interface Gateway extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + forwardCall( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + forwardCall( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + forwardCall( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Forwarded(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ForwardedEventFilter; + Forwarded( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ForwardedEventFilter; + }; + + estimateGas: { + forwardCall( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + forwardCall( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/Receiver.ts b/typechain-types/contracts/prototypes/Receiver.ts new file mode 100644 index 00000000..447cc112 --- /dev/null +++ b/typechain-types/contracts/prototypes/Receiver.ts @@ -0,0 +1,232 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface ReceiverInterface extends utils.Interface { + functions: { + "receiveA(string,uint256,bool)": FunctionFragment; + "receiveB(string[],uint256[],bool)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "receiveA" | "receiveB" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "receiveA", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "receiveB", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; + + events: { + "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; + "ReceivedB(address,uint256,string[],uint256[],bool)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; +} + +export interface ReceivedAEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedAEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedAEventObject +>; + +export type ReceivedAEventFilter = TypedEventFilter; + +export interface ReceivedBEventObject { + sender: string; + value: BigNumber; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedBEvent = TypedEvent< + [string, BigNumber, string[], BigNumber[], boolean], + ReceivedBEventObject +>; + +export type ReceivedBEventFilter = TypedEventFilter; + +export interface Receiver extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ReceiverInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "ReceivedA(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + ReceivedA( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + + "ReceivedB(address,uint256,string[],uint256[],bool)"( + sender?: null, + value?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + ReceivedB( + sender?: null, + value?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + }; + + estimateGas: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts new file mode 100644 index 00000000..993ba38c --- /dev/null +++ b/typechain-types/contracts/prototypes/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { Gateway } from "./Gateway"; +export type { Receiver } from "./Receiver"; diff --git a/typechain-types/factories/contracts/index.ts b/typechain-types/factories/contracts/index.ts index 33289123..bcdd9858 100644 --- a/typechain-types/factories/contracts/index.ts +++ b/typechain-types/factories/contracts/index.ts @@ -2,4 +2,5 @@ /* tslint:disable */ /* eslint-disable */ export * as evm from "./evm"; +export * as prototypes from "./prototypes"; export * as zevm from "./zevm"; diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts new file mode 100644 index 00000000..174c824e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -0,0 +1,112 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + Gateway, + GatewayInterface, +} from "../../../contracts/prototypes/Gateway"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Forwarded", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "forwardCall", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Gateway__factory extends ContractFactory { + constructor(...args: GatewayConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): Gateway { + return super.attach(address) as Gateway; + } + override connect(signer: Signer): Gateway__factory { + return super.connect(signer) as Gateway__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayInterface { + return new utils.Interface(_abi) as GatewayInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Gateway { + return new Contract(address, _abi, signerOrProvider) as Gateway; + } +} diff --git a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts new file mode 100644 index 00000000..651b9ff0 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts @@ -0,0 +1,183 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + Receiver, + ReceiverInterface, +} from "../../../contracts/prototypes/Receiver"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedA", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedB", + type: "event", + }, + { + inputs: [ + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveA", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveB", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ReceiverConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ReceiverConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Receiver__factory extends ContractFactory { + constructor(...args: ReceiverConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): Receiver { + return super.attach(address) as Receiver; + } + override connect(signer: Signer): Receiver__factory { + return super.connect(signer) as Receiver__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ReceiverInterface { + return new utils.Interface(_abi) as ReceiverInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Receiver { + return new Contract(address, _abi, signerOrProvider) as Receiver; + } +} diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts new file mode 100644 index 00000000..28689ac1 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { Gateway__factory } from "./Gateway__factory"; +export { Receiver__factory } from "./Receiver__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 08c44b83..086156ef 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -300,6 +300,14 @@ declare module "hardhat/types/runtime" { name: "ZetaConnectorNonEth", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "Gateway", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "Receiver", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -729,6 +737,16 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "Gateway", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "Receiver", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index c86b173d..8ee5ddbc 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -140,6 +140,10 @@ export type { ZetaConnectorEth } from "./contracts/evm/ZetaConnector.eth.sol/Zet export { ZetaConnectorEth__factory } from "./factories/contracts/evm/ZetaConnector.eth.sol/ZetaConnectorEth__factory"; export type { ZetaConnectorNonEth } from "./contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth"; export { ZetaConnectorNonEth__factory } from "./factories/contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth__factory"; +export type { Gateway } from "./contracts/prototypes/Gateway"; +export { Gateway__factory } from "./factories/contracts/prototypes/Gateway__factory"; +export type { Receiver } from "./contracts/prototypes/Receiver"; +export { Receiver__factory } from "./factories/contracts/prototypes/Receiver__factory"; export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; From 6aed43c93d3900874969a54408401c17997e7cb9 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 14:52:04 +0200 Subject: [PATCH 06/86] change B to non-payable --- contracts/prototypes/Receiver.sol | 6 +++--- test/prototypes/GatewayIntegration.spec.ts | 5 ++--- .../contracts/prototypes/Receiver.ts | 18 ++++++++---------- .../contracts/prototypes/Receiver__factory.ts | 10 ++-------- 4 files changed, 15 insertions(+), 24 deletions(-) diff --git a/contracts/prototypes/Receiver.sol b/contracts/prototypes/Receiver.sol index 8a49d710..7275fee1 100644 --- a/contracts/prototypes/Receiver.sol +++ b/contracts/prototypes/Receiver.sol @@ -3,13 +3,13 @@ pragma solidity 0.8.7; contract Receiver { event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); - event ReceivedB(address sender, uint256 value, string[] strs, uint256[] nums, bool flag); + event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); function receiveA(string memory str, uint256 num, bool flag) external payable { emit ReceivedA(msg.sender, msg.value, str, num, flag); } - function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external payable { - emit ReceivedB(msg.sender, msg.value, strs, nums, flag); + function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external { + emit ReceivedB(msg.sender, strs, nums, flag); } } \ No newline at end of file diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 03d111a7..f650a982 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -41,12 +41,11 @@ describe("Gateway and Receiver", function () { const strs = ["Hello", "Hardhat"]; const nums = [1, 2, 3]; const flag = false; - const value = ethers.utils.parseEther("0.5"); const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); - const tx = await gateway.forwardCall(receiver.address, data, { value: value }); + const tx = await gateway.forwardCall(receiver.address, data); await tx.wait(); await expect(tx) .to.emit(receiver, "ReceivedB") - .withArgs(gateway.address, value, strs, nums, flag); + .withArgs(gateway.address, strs, nums, flag); }); }); \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/Receiver.ts b/typechain-types/contracts/prototypes/Receiver.ts index 447cc112..7bcfec8b 100644 --- a/typechain-types/contracts/prototypes/Receiver.ts +++ b/typechain-types/contracts/prototypes/Receiver.ts @@ -8,6 +8,7 @@ import type { BytesLike, CallOverrides, ContractTransaction, + Overrides, PayableOverrides, PopulatedTransaction, Signer, @@ -59,7 +60,7 @@ export interface ReceiverInterface extends utils.Interface { events: { "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; - "ReceivedB(address,uint256,string[],uint256[],bool)": EventFragment; + "ReceivedB(address,string[],uint256[],bool)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; @@ -82,13 +83,12 @@ export type ReceivedAEventFilter = TypedEventFilter; export interface ReceivedBEventObject { sender: string; - value: BigNumber; strs: string[]; nums: BigNumber[]; flag: boolean; } export type ReceivedBEvent = TypedEvent< - [string, BigNumber, string[], BigNumber[], boolean], + [string, string[], BigNumber[], boolean], ReceivedBEventObject >; @@ -132,7 +132,7 @@ export interface Receiver extends BaseContract { strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; }; @@ -147,7 +147,7 @@ export interface Receiver extends BaseContract { strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; callStatic: { @@ -182,16 +182,14 @@ export interface Receiver extends BaseContract { flag?: null ): ReceivedAEventFilter; - "ReceivedB(address,uint256,string[],uint256[],bool)"( + "ReceivedB(address,string[],uint256[],bool)"( sender?: null, - value?: null, strs?: null, nums?: null, flag?: null ): ReceivedBEventFilter; ReceivedB( sender?: null, - value?: null, strs?: null, nums?: null, flag?: null @@ -210,7 +208,7 @@ export interface Receiver extends BaseContract { strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; }; @@ -226,7 +224,7 @@ export interface Receiver extends BaseContract { strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; }; } diff --git a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts index 651b9ff0..e86bc2fd 100644 --- a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts @@ -56,12 +56,6 @@ const _abi = [ name: "sender", type: "address", }, - { - indexed: false, - internalType: "uint256", - name: "value", - type: "uint256", - }, { indexed: false, internalType: "string[]", @@ -127,13 +121,13 @@ const _abi = [ ], name: "receiveB", outputs: [], - stateMutability: "payable", + stateMutability: "nonpayable", type: "function", }, ] as const; const _bytecode = - "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"; + "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"; type ReceiverConstructorParams = | [signer?: Signer] From 8a973c18db12c8d533026fa3a132262e43d231b6 Mon Sep 17 00:00:00 2001 From: lumtis Date: Tue, 18 Jun 2024 15:05:22 +0200 Subject: [PATCH 07/86] generate --- .../contract.ZetaTokenConsumerZEVM.md | 94 ++++ .../interface.ZetaTokenConsumerZEVMErrors.md | 53 ++ .../prototypes/gateway.sol/gateway.go | 370 +++++++++++++ .../prototypes/receiver.sol/receiver.go | 520 ++++++++++++++++++ test/prototypes/GatewayIntegration.spec.ts | 12 +- 5 files changed, 1041 insertions(+), 8 deletions(-) create mode 100644 docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/contract.ZetaTokenConsumerZEVM.md create mode 100644 docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md create mode 100644 pkg/contracts/prototypes/gateway.sol/gateway.go create mode 100644 pkg/contracts/prototypes/receiver.sol/receiver.go diff --git a/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/contract.ZetaTokenConsumerZEVM.md b/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/contract.ZetaTokenConsumerZEVM.md new file mode 100644 index 00000000..05639448 --- /dev/null +++ b/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/contract.ZetaTokenConsumerZEVM.md @@ -0,0 +1,94 @@ +# ZetaTokenConsumerZEVM +[Git Source](https://github.com/zeta-chain/protocol-contracts/blob/6aed43c93d3900874969a54408401c17997e7cb9/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol) + +**Inherits:** +[ZetaTokenConsumer](/contracts/evm/interfaces/ZetaInterfaces.sol/interface.ZetaTokenConsumer.md), [ZetaTokenConsumerZEVMErrors](/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md) + +*ZetaTokenConsumer for ZEVM* + + +## State Variables +### MAX_DEADLINE + +```solidity +uint256 internal constant MAX_DEADLINE = 200; +``` + + +### WETH9Address + +```solidity +address public immutable WETH9Address; +``` + + +### uniswapV2Router + +```solidity +IUniswapV2Router02 internal immutable uniswapV2Router; +``` + + +## Functions +### constructor + + +```solidity +constructor(address WETH9Address_, address uniswapV2Router_); +``` + +### getZetaFromEth + + +```solidity +function getZetaFromEth(address destinationAddress, uint256 minAmountOut) external payable override returns (uint256); +``` + +### getZetaFromToken + + +```solidity +function getZetaFromToken( + address destinationAddress, + uint256 minAmountOut, + address inputToken, + uint256 inputTokenAmount +) external override returns (uint256); +``` + +### getEthFromZeta + + +```solidity +function getEthFromZeta(address destinationAddress, uint256 minAmountOut, uint256 zetaTokenAmount) + external + override + returns (uint256); +``` + +### getTokenFromZeta + + +```solidity +function getTokenFromZeta( + address destinationAddress, + uint256 minAmountOut, + address outputToken, + uint256 zetaTokenAmount +) external override returns (uint256); +``` + +### hasZetaLiquidity + + +```solidity +function hasZetaLiquidity() external view override returns (bool); +``` + +### receive + + +```solidity +receive() external payable; +``` + diff --git a/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md b/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md new file mode 100644 index 00000000..86267001 --- /dev/null +++ b/docs/src/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol/interface.ZetaTokenConsumerZEVMErrors.md @@ -0,0 +1,53 @@ +# ZetaTokenConsumerZEVMErrors +[Git Source](https://github.com/zeta-chain/protocol-contracts/blob/6aed43c93d3900874969a54408401c17997e7cb9/contracts/evm/tools/ZetaTokenConsumerZEVM.strategy.sol) + + +## Errors +### InputCantBeZero + +```solidity +error InputCantBeZero(); +``` + +### ErrorSendingETH + +```solidity +error ErrorSendingETH(); +``` + +### ReentrancyError + +```solidity +error ReentrancyError(); +``` + +### NotEnoughValue + +```solidity +error NotEnoughValue(); +``` + +### InputCantBeZeta + +```solidity +error InputCantBeZeta(); +``` + +### OutputCantBeZeta + +```solidity +error OutputCantBeZeta(); +``` + +### OnlyWZETAAllowed + +```solidity +error OnlyWZETAAllowed(); +``` + +### InvalidForZEVM + +```solidity +error InvalidForZEVM(); +``` + diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go new file mode 100644 index 00000000..5d4d40ff --- /dev/null +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -0,0 +1,370 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gateway + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayMetaData contains all meta data concerning the Gateway contract. +var GatewayMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Forwarded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"forwardCall\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayMetaData.ABI instead. +var GatewayABI = GatewayMetaData.ABI + +// GatewayBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayMetaData.Bin instead. +var GatewayBin = GatewayMetaData.Bin + +// DeployGateway deploys a new Ethereum contract, binding an instance of Gateway to it. +func DeployGateway(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Gateway, error) { + parsed, err := GatewayMetaData.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(GatewayBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Gateway{GatewayCaller: GatewayCaller{contract: contract}, GatewayTransactor: GatewayTransactor{contract: contract}, GatewayFilterer: GatewayFilterer{contract: contract}}, nil +} + +// Gateway is an auto generated Go binding around an Ethereum contract. +type Gateway struct { + GatewayCaller // Read-only binding to the contract + GatewayTransactor // Write-only binding to the contract + GatewayFilterer // Log filterer for contract events +} + +// GatewayCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewaySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewaySession struct { + Contract *Gateway // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayCallerSession struct { + Contract *GatewayCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayTransactorSession struct { + Contract *GatewayTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayRaw struct { + Contract *Gateway // Generic contract binding to access the raw methods on +} + +// GatewayCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayCallerRaw struct { + Contract *GatewayCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayTransactorRaw struct { + Contract *GatewayTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGateway creates a new instance of Gateway, bound to a specific deployed contract. +func NewGateway(address common.Address, backend bind.ContractBackend) (*Gateway, error) { + contract, err := bindGateway(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Gateway{GatewayCaller: GatewayCaller{contract: contract}, GatewayTransactor: GatewayTransactor{contract: contract}, GatewayFilterer: GatewayFilterer{contract: contract}}, nil +} + +// NewGatewayCaller creates a new read-only instance of Gateway, bound to a specific deployed contract. +func NewGatewayCaller(address common.Address, caller bind.ContractCaller) (*GatewayCaller, error) { + contract, err := bindGateway(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayCaller{contract: contract}, nil +} + +// NewGatewayTransactor creates a new write-only instance of Gateway, bound to a specific deployed contract. +func NewGatewayTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayTransactor, error) { + contract, err := bindGateway(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayTransactor{contract: contract}, nil +} + +// NewGatewayFilterer creates a new log filterer instance of Gateway, bound to a specific deployed contract. +func NewGatewayFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayFilterer, error) { + contract, err := bindGateway(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayFilterer{contract: contract}, nil +} + +// bindGateway binds a generic wrapper to an already deployed contract. +func bindGateway(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Gateway *GatewayRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Gateway.Contract.GatewayCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Gateway *GatewayRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Gateway.Contract.GatewayTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Gateway *GatewayRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Gateway.Contract.GatewayTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Gateway *GatewayCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Gateway.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Gateway *GatewayTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Gateway.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Gateway *GatewayTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Gateway.Contract.contract.Transact(opts, method, params...) +} + +// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// +// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewayTransactor) ForwardCall(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "forwardCall", destination, data) +} + +// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// +// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewaySession) ForwardCall(destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.ForwardCall(&_Gateway.TransactOpts, destination, data) +} + +// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// +// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewayTransactorSession) ForwardCall(destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.ForwardCall(&_Gateway.TransactOpts, destination, data) +} + +// GatewayForwardedIterator is returned from FilterForwarded and is used to iterate over the raw logs and unpacked data for Forwarded events raised by the Gateway contract. +type GatewayForwardedIterator struct { + Event *GatewayForwarded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayForwardedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayForwarded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayForwarded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayForwardedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayForwardedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayForwarded represents a Forwarded event raised by the Gateway contract. +type GatewayForwarded struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterForwarded is a free log retrieval operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// +// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) FilterForwarded(opts *bind.FilterOpts, destination []common.Address) (*GatewayForwardedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Forwarded", destinationRule) + if err != nil { + return nil, err + } + return &GatewayForwardedIterator{contract: _Gateway.contract, event: "Forwarded", logs: logs, sub: sub}, nil +} + +// WatchForwarded is a free log subscription operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// +// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) WatchForwarded(opts *bind.WatchOpts, sink chan<- *GatewayForwarded, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "Forwarded", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayForwarded) + if err := _Gateway.contract.UnpackLog(event, "Forwarded", 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 +} + +// ParseForwarded is a log parse operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// +// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) ParseForwarded(log types.Log) (*GatewayForwarded, error) { + event := new(GatewayForwarded) + if err := _Gateway.contract.UnpackLog(event, "Forwarded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/receiver.sol/receiver.go b/pkg/contracts/prototypes/receiver.sol/receiver.go new file mode 100644 index 00000000..19b4531c --- /dev/null +++ b/pkg/contracts/prototypes/receiver.sol/receiver.go @@ -0,0 +1,520 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package receiver + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ReceiverMetaData contains all meta data concerning the Receiver contract. +var ReceiverMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "0x608060405234801561001057600080fd5b50610906806100206000396000f3fe6080604052600436106100295760003560e01c80636fa220ad1461002e578063f5db6b391461004a575b600080fd5b61004860048036038101906100439190610378565b610073565b005b34801561005657600080fd5b50610071600480360381019061006c91906102ed565b6100b7565b005b7f87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee33348585856040516100aa9594939291906105e7565b60405180910390a1505050565b7f463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2338484846040516100ec9493929190610594565b60405180910390a1505050565b600061010c61010784610666565b610641565b9050808382526020820190508285602086028201111561012f5761012e61087d565b5b60005b8581101561017d57813567ffffffffffffffff81111561015557610154610878565b5b80860161016289826102aa565b85526020850194506020840193505050600181019050610132565b5050509392505050565b600061019a61019584610692565b610641565b905080838252602082019050828560208602820111156101bd576101bc61087d565b5b60005b858110156101ed57816101d388826102d8565b8452602084019350602083019250506001810190506101c0565b5050509392505050565b600061020a610205846106be565b610641565b90508281526020810184848401111561022657610225610882565b5b6102318482856107d6565b509392505050565b600082601f83011261024e5761024d610878565b5b813561025e8482602086016100f9565b91505092915050565b600082601f83011261027c5761027b610878565b5b813561028c848260208601610187565b91505092915050565b6000813590506102a4816108a2565b92915050565b600082601f8301126102bf576102be610878565b5b81356102cf8482602086016101f7565b91505092915050565b6000813590506102e7816108b9565b92915050565b6000806000606084860312156103065761030561088c565b5b600084013567ffffffffffffffff81111561032457610323610887565b5b61033086828701610239565b935050602084013567ffffffffffffffff81111561035157610350610887565b5b61035d86828701610267565b925050604061036e86828701610295565b9150509250925092565b6000806000606084860312156103915761039061088c565b5b600084013567ffffffffffffffff8111156103af576103ae610887565b5b6103bb868287016102aa565b93505060206103cc868287016102d8565b92505060406103dd86828701610295565b9150509250925092565b60006103f38383610504565b905092915050565b60006104078383610576565b60208301905092915050565b61041c8161078e565b82525050565b600061042d8261070f565b610437818561074a565b935083602082028501610449856106ef565b8060005b85811015610485578484038952815161046685826103e7565b945061047183610730565b925060208a0199505060018101905061044d565b50829750879550505050505092915050565b60006104a28261071a565b6104ac818561075b565b93506104b7836106ff565b8060005b838110156104e85781516104cf88826103fb565b97506104da8361073d565b9250506001810190506104bb565b5085935050505092915050565b6104fe816107a0565b82525050565b600061050f82610725565b610519818561076c565b93506105298185602086016107e5565b61053281610891565b840191505092915050565b600061054882610725565b610552818561077d565b93506105628185602086016107e5565b61056b81610891565b840191505092915050565b61057f816107cc565b82525050565b61058e816107cc565b82525050565b60006080820190506105a96000830187610413565b81810360208301526105bb8186610422565b905081810360408301526105cf8185610497565b90506105de60608301846104f5565b95945050505050565b600060a0820190506105fc6000830188610413565b6106096020830187610585565b818103604083015261061b818661053d565b905061062a6060830185610585565b61063760808301846104f5565b9695505050505050565b600061064b61065c565b90506106578282610818565b919050565b6000604051905090565b600067ffffffffffffffff82111561068157610680610849565b5b602082029050602081019050919050565b600067ffffffffffffffff8211156106ad576106ac610849565b5b602082029050602081019050919050565b600067ffffffffffffffff8211156106d9576106d8610849565b5b6106e282610891565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000610799826107ac565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156108035780820151818401526020810190506107e8565b83811115610812576000848401525b50505050565b61082182610891565b810181811067ffffffffffffffff821117156108405761083f610849565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b6108ab816107a0565b81146108b657600080fd5b50565b6108c2816107cc565b81146108cd57600080fd5b5056fea2646970667358221220a471fde0547689c02df444b3d3f058d18c9dd15c58325e79133a63a1cc3608dd64736f6c63430008070033", +} + +// ReceiverABI is the input ABI used to generate the binding from. +// Deprecated: Use ReceiverMetaData.ABI instead. +var ReceiverABI = ReceiverMetaData.ABI + +// ReceiverBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ReceiverMetaData.Bin instead. +var ReceiverBin = ReceiverMetaData.Bin + +// DeployReceiver deploys a new Ethereum contract, binding an instance of Receiver to it. +func DeployReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Receiver, error) { + parsed, err := ReceiverMetaData.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(ReceiverBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil +} + +// Receiver is an auto generated Go binding around an Ethereum contract. +type Receiver struct { + ReceiverCaller // Read-only binding to the contract + ReceiverTransactor // Write-only binding to the contract + ReceiverFilterer // Log filterer for contract events +} + +// ReceiverCaller is an auto generated read-only Go binding around an Ethereum contract. +type ReceiverCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ReceiverTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ReceiverTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ReceiverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ReceiverFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ReceiverSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ReceiverSession struct { + Contract *Receiver // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ReceiverCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ReceiverCallerSession struct { + Contract *ReceiverCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ReceiverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ReceiverTransactorSession struct { + Contract *ReceiverTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ReceiverRaw is an auto generated low-level Go binding around an Ethereum contract. +type ReceiverRaw struct { + Contract *Receiver // Generic contract binding to access the raw methods on +} + +// ReceiverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ReceiverCallerRaw struct { + Contract *ReceiverCaller // Generic read-only contract binding to access the raw methods on +} + +// ReceiverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ReceiverTransactorRaw struct { + Contract *ReceiverTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewReceiver creates a new instance of Receiver, bound to a specific deployed contract. +func NewReceiver(address common.Address, backend bind.ContractBackend) (*Receiver, error) { + contract, err := bindReceiver(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil +} + +// NewReceiverCaller creates a new read-only instance of Receiver, bound to a specific deployed contract. +func NewReceiverCaller(address common.Address, caller bind.ContractCaller) (*ReceiverCaller, error) { + contract, err := bindReceiver(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ReceiverCaller{contract: contract}, nil +} + +// NewReceiverTransactor creates a new write-only instance of Receiver, bound to a specific deployed contract. +func NewReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*ReceiverTransactor, error) { + contract, err := bindReceiver(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ReceiverTransactor{contract: contract}, nil +} + +// NewReceiverFilterer creates a new log filterer instance of Receiver, bound to a specific deployed contract. +func NewReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*ReceiverFilterer, error) { + contract, err := bindReceiver(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ReceiverFilterer{contract: contract}, nil +} + +// bindReceiver binds a generic wrapper to an already deployed contract. +func bindReceiver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ReceiverMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Receiver *ReceiverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Receiver.Contract.ReceiverCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Receiver *ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Receiver.Contract.ReceiverTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Receiver *ReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Receiver.Contract.ReceiverTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Receiver *ReceiverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Receiver.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Receiver *ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Receiver.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Receiver *ReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Receiver.Contract.contract.Transact(opts, method, params...) +} + +// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// +// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() +func (_Receiver *ReceiverTransactor) ReceiveA(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.contract.Transact(opts, "receiveA", str, num, flag) +} + +// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// +// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() +func (_Receiver *ReceiverSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveA(&_Receiver.TransactOpts, str, num, flag) +} + +// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// +// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() +func (_Receiver *ReceiverTransactorSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveA(&_Receiver.TransactOpts, str, num, flag) +} + +// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// +// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() +func (_Receiver *ReceiverTransactor) ReceiveB(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.contract.Transact(opts, "receiveB", strs, nums, flag) +} + +// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// +// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() +func (_Receiver *ReceiverSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveB(&_Receiver.TransactOpts, strs, nums, flag) +} + +// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// +// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() +func (_Receiver *ReceiverTransactorSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveB(&_Receiver.TransactOpts, strs, nums, flag) +} + +// ReceiverReceivedAIterator is returned from FilterReceivedA and is used to iterate over the raw logs and unpacked data for ReceivedA events raised by the Receiver contract. +type ReceiverReceivedAIterator struct { + Event *ReceiverReceivedA // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ReceiverReceivedAIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedA) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ReceiverReceivedAIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ReceiverReceivedAIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ReceiverReceivedA represents a ReceivedA event raised by the Receiver contract. +type ReceiverReceivedA struct { + Sender common.Address + Value *big.Int + Str string + Num *big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedA is a free log retrieval operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// +// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) +func (_Receiver *ReceiverFilterer) FilterReceivedA(opts *bind.FilterOpts) (*ReceiverReceivedAIterator, error) { + + logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedA") + if err != nil { + return nil, err + } + return &ReceiverReceivedAIterator{contract: _Receiver.contract, event: "ReceivedA", logs: logs, sub: sub}, nil +} + +// WatchReceivedA is a free log subscription operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// +// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) +func (_Receiver *ReceiverFilterer) WatchReceivedA(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedA) (event.Subscription, error) { + + logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedA") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ReceiverReceivedA) + if err := _Receiver.contract.UnpackLog(event, "ReceivedA", 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 +} + +// ParseReceivedA is a log parse operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// +// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) +func (_Receiver *ReceiverFilterer) ParseReceivedA(log types.Log) (*ReceiverReceivedA, error) { + event := new(ReceiverReceivedA) + if err := _Receiver.contract.UnpackLog(event, "ReceivedA", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ReceiverReceivedBIterator is returned from FilterReceivedB and is used to iterate over the raw logs and unpacked data for ReceivedB events raised by the Receiver contract. +type ReceiverReceivedBIterator struct { + Event *ReceiverReceivedB // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ReceiverReceivedBIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedB) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedB) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ReceiverReceivedBIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ReceiverReceivedBIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ReceiverReceivedB represents a ReceivedB event raised by the Receiver contract. +type ReceiverReceivedB struct { + Sender common.Address + Strs []string + Nums []*big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedB is a free log retrieval operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// +// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) +func (_Receiver *ReceiverFilterer) FilterReceivedB(opts *bind.FilterOpts) (*ReceiverReceivedBIterator, error) { + + logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedB") + if err != nil { + return nil, err + } + return &ReceiverReceivedBIterator{contract: _Receiver.contract, event: "ReceivedB", logs: logs, sub: sub}, nil +} + +// WatchReceivedB is a free log subscription operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// +// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) +func (_Receiver *ReceiverFilterer) WatchReceivedB(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedB) (event.Subscription, error) { + + logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedB") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ReceiverReceivedB) + if err := _Receiver.contract.UnpackLog(event, "ReceivedB", 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 +} + +// ParseReceivedB is a log parse operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// +// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) +func (_Receiver *ReceiverFilterer) ParseReceivedB(log types.Log) (*ReceiverReceivedB, error) { + event := new(ReceiverReceivedB) + if err := _Receiver.contract.UnpackLog(event, "ReceivedB", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index f650a982..a93fde15 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -1,6 +1,6 @@ import { expect } from "chai"; -import { ethers } from "hardhat"; import { Contract } from "ethers"; +import { ethers } from "hardhat"; describe("Gateway and Receiver", function () { let receiver: Contract; @@ -32,9 +32,7 @@ describe("Gateway and Receiver", function () { await tx.wait(); // Listen for the event - await expect(tx) - .to.emit(receiver, "ReceivedA") - .withArgs(gateway.address, value, str, num, flag); + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); }); it("should forward call to Receiver's receiveB function", async function () { @@ -44,8 +42,6 @@ describe("Gateway and Receiver", function () { const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); const tx = await gateway.forwardCall(receiver.address, data); await tx.wait(); - await expect(tx) - .to.emit(receiver, "ReceivedB") - .withArgs(gateway.address, strs, nums, flag); + await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); }); -}); \ No newline at end of file +}); From d562400c115557dd197b19e8bd14383e357370df Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 12:50:36 +0200 Subject: [PATCH 08/86] initialize custody contract --- contracts/prototypes/ERC20Custody.sol | 32 +++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 contracts/prototypes/ERC20Custody.sol diff --git a/contracts/prototypes/ERC20Custody.sol b/contracts/prototypes/ERC20Custody.sol new file mode 100644 index 00000000..02444369 --- /dev/null +++ b/contracts/prototypes/ERC20Custody.sol @@ -0,0 +1,32 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "./Gateway.sol"; + +contract ERC20Custody { + Gateway public gateway; + + event Withdraw(address indexed token, address indexed to, uint256 amount); + event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data); + + constructor(address _gateway) { + gateway = Gateway(_gateway); + } + + function withdraw(address token, address to, uint256 amount) external { + IERC20(token).transfer(to, amount); + + emit Withdraw(token, to, amount); + } + + function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external { + // Transfer the tokens to the Gateway contract + IERC20(token).transfer(address(gateway), amount); + + // Forward the call to the Gateway contract + gateway.executeWithERC20(token, to, amount, data); + + emit WithdrawAndCall(token, to, amount, data); + } +} \ No newline at end of file From 555ff9d41d90d21d56367c2ad60ecf7bb50847d4 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 12:50:56 +0200 Subject: [PATCH 09/86] add execute with erc20 in gateway --- contracts/prototypes/Gateway.sol | 45 +++++++++++++++++++++++++++---- contracts/prototypes/Receiver.sol | 10 +++++++ 2 files changed, 50 insertions(+), 5 deletions(-) diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 4f9e3bbd..0564065d 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -1,15 +1,50 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "./ERC20Custody.sol"; + contract Gateway { - event Forwarded(address indexed destination, uint256 value, bytes data); + ERC20Custody public custody; + + event Executed(address indexed destination, uint256 value, bytes data); + event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); + + constructor(address _custody) { + custody = ERC20Custody(_custody); + } - function forwardCall(address destination, bytes calldata data) external payable returns (bytes memory) { + function _execute(address destination, bytes calldata data) internal returns (bytes memory) { (bool success, bytes memory result) = destination.call{value: msg.value}(data); - require(success, "Call failed"); - - emit Forwarded(destination, msg.value, data); + return result; + } + + function execute(address destination, bytes calldata data) external payable returns (bytes memory) { + bytes memory result = _execute(destination, data); + + emit Executed(destination, msg.value, data); + + return result; + } + + function executeWithERC20(address token, address to, uint256 amount, bytes calldata data) external returns (bytes memory) { + // Approve the target contract to spend the tokens + IERC20(token).approve(to, amount); + + // Execute the call on the target contract + bytes memory result = _execute(to, data); + + // Reset approval + IERC20(token).approve(to, 0); + + // Transfer any remaining tokens back to the custody contract + uint256 remainingBalance = IERC20(token).balanceOf(address(this)); + if (remainingBalance > 0) { + IERC20(token).transfer(address(custody), remainingBalance); + } + + emit ExecutedWithERC20(token, to, amount, data); return result; } diff --git a/contracts/prototypes/Receiver.sol b/contracts/prototypes/Receiver.sol index 7275fee1..0fc941d0 100644 --- a/contracts/prototypes/Receiver.sol +++ b/contracts/prototypes/Receiver.sol @@ -1,9 +1,12 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + contract Receiver { event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); + event ReceivedC(address sender, uint256 amount, address token, address destination); function receiveA(string memory str, uint256 num, bool flag) external payable { emit ReceivedA(msg.sender, msg.value, str, num, flag); @@ -12,4 +15,11 @@ contract Receiver { function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external { emit ReceivedB(msg.sender, strs, nums, flag); } + + function receiveC(uint256 amount, address token, address destination) external { + // Transfer tokens from the Gateway contract to the destination address + IERC20(token).transferFrom(msg.sender, destination, amount); + + emit ReceivedC(msg.sender, amount, token, destination); + } } \ No newline at end of file From 21b8ace4996e3ec9f7e2b9f54110eee2d473cf22 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 13:42:01 +0200 Subject: [PATCH 10/86] add test --- .../{ERC20Custody.sol => ERC20CustodyNew.sol} | 2 +- contracts/prototypes/Gateway.sol | 21 +- contracts/prototypes/TestERC20.sol | 12 + test/prototypes/GatewayIntegration.spec.ts | 119 +++-- .../contracts/prototypes/ERC20Custody.ts | 245 +++++++++ .../contracts/prototypes/ERC20CustodyNew.ts | 245 +++++++++ .../contracts/prototypes/Gateway.ts | 170 +++++- .../contracts/prototypes/Receiver.ts | 75 ++- .../contracts/prototypes/TestERC20.ts | 501 ++++++++++++++++++ typechain-types/contracts/prototypes/index.ts | 2 + .../prototypes/ERC20CustodyNew__factory.ts | 196 +++++++ .../prototypes/ERC20Custody__factory.ts | 196 +++++++ .../contracts/prototypes/Gateway__factory.ts | 97 +++- .../contracts/prototypes/Receiver__factory.ts | 56 +- .../prototypes/TestERC20__factory.ts | 371 +++++++++++++ .../factories/contracts/prototypes/index.ts | 2 + typechain-types/hardhat.d.ts | 18 + typechain-types/index.ts | 4 + 18 files changed, 2257 insertions(+), 75 deletions(-) rename contracts/prototypes/{ERC20Custody.sol => ERC20CustodyNew.sol} (97%) create mode 100644 contracts/prototypes/TestERC20.sol create mode 100644 typechain-types/contracts/prototypes/ERC20Custody.ts create mode 100644 typechain-types/contracts/prototypes/ERC20CustodyNew.ts create mode 100644 typechain-types/contracts/prototypes/TestERC20.ts create mode 100644 typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/ERC20Custody__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/TestERC20__factory.ts diff --git a/contracts/prototypes/ERC20Custody.sol b/contracts/prototypes/ERC20CustodyNew.sol similarity index 97% rename from contracts/prototypes/ERC20Custody.sol rename to contracts/prototypes/ERC20CustodyNew.sol index 02444369..a88a35a7 100644 --- a/contracts/prototypes/ERC20Custody.sol +++ b/contracts/prototypes/ERC20CustodyNew.sol @@ -4,7 +4,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./Gateway.sol"; -contract ERC20Custody { +contract ERC20CustodyNew { Gateway public gateway; event Withdraw(address indexed token, address indexed to, uint256 amount); diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 0564065d..e6fbe0c4 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -2,18 +2,14 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./ERC20Custody.sol"; +import "./ERC20CustodyNew.sol"; contract Gateway { - ERC20Custody public custody; + ERC20CustodyNew public custody; event Executed(address indexed destination, uint256 value, bytes data); event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); - constructor(address _custody) { - custody = ERC20Custody(_custody); - } - function _execute(address destination, bytes calldata data) internal returns (bytes memory) { (bool success, bytes memory result) = destination.call{value: msg.value}(data); require(success, "Call failed"); @@ -28,7 +24,12 @@ contract Gateway { return result; } - function executeWithERC20(address token, address to, uint256 amount, bytes calldata data) external returns (bytes memory) { + function executeWithERC20( + address token, + address to, + uint256 amount, + bytes calldata data + ) external returns (bytes memory) { // Approve the target contract to spend the tokens IERC20(token).approve(to, amount); @@ -48,4 +49,8 @@ contract Gateway { return result; } -} \ No newline at end of file + + function setCustody(address _custody) external { + custody = ERC20CustodyNew(_custody); + } +} diff --git a/contracts/prototypes/TestERC20.sol b/contracts/prototypes/TestERC20.sol new file mode 100644 index 00000000..6a9859c3 --- /dev/null +++ b/contracts/prototypes/TestERC20.sol @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; + +contract TestERC20 is ERC20 { + constructor(string memory name, string memory symbol) ERC20(name, symbol) {} + + function mint(address to, uint256 amount) external { + _mint(to, amount); + } +} \ No newline at end of file diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index a93fde15..b0d07669 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -3,45 +3,80 @@ import { Contract } from "ethers"; import { ethers } from "hardhat"; describe("Gateway and Receiver", function () { - let receiver: Contract; - let gateway: Contract; - let owner: any, addr1: any; - - beforeEach(async function () { - // Get the ContractFactories and Signers - const Receiver = await ethers.getContractFactory("Receiver"); - const Gateway = await ethers.getContractFactory("Gateway"); - [owner, addr1] = await ethers.getSigners(); - - // Deploy the contracts - receiver = await Receiver.deploy(); - gateway = await Gateway.deploy(); - }); - - it("should forward call to Receiver's receiveA function", async function () { - const str = "Hello, Hardhat!"; - const num = 42; - const flag = true; - const value = ethers.utils.parseEther("1.0"); - - // Encode the function call data - const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); - - // Call forwardCall on the Gateway contract - const tx = await gateway.forwardCall(receiver.address, data, { value: value }); - await tx.wait(); - - // Listen for the event - await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); - }); - - it("should forward call to Receiver's receiveB function", async function () { - const strs = ["Hello", "Hardhat"]; - const nums = [1, 2, 3]; - const flag = false; - const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); - const tx = await gateway.forwardCall(receiver.address, data); - await tx.wait(); - await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); - }); -}); + let receiver: Contract; + let gateway: Contract; + let token: Contract; + let custody: Contract; + let owner: any, destination: any; + + beforeEach(async function () { + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const Receiver = await ethers.getContractFactory("Receiver"); + const Gateway = await ethers.getContractFactory("Gateway"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + [owner, destination] = await ethers.getSigners(); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + receiver = await Receiver.deploy(); + gateway = await Gateway.deploy(); + custody = await Custody.deploy(gateway.address); + + gateway.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(owner.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + }); + + it("should forward call to Receiver's receiveA function", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data + const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); + + // Call execute on the Gateway contract + const tx = await gateway.execute(receiver.address, data, { value: value }); + await tx.wait(); + + // Listen for the event + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); + }); + + it("should forward call to Receiver's receiveB function", async function () { + const strs = ["Hello", "Hardhat"]; + const nums = [1, 2, 3]; + const flag = false; + const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); + const tx = await gateway.execute(receiver.address, data); + await tx.wait(); + await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); + }); + + it("should forward call with withdrawAndCall and give allowance to destination contract", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveC + const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); + + // Withdraw and call + await custody.withdrawAndCall(token.address, receiver.address, amount, data); + + // Verify that the tokens were transferred to the destination address + const receiverBalance = await token.balanceOf(destination.address); + expect(receiverBalance).to.equal(amount); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("400")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); +}); \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/ERC20Custody.ts b/typechain-types/contracts/prototypes/ERC20Custody.ts new file mode 100644 index 00000000..f1b2b774 --- /dev/null +++ b/typechain-types/contracts/prototypes/ERC20Custody.ts @@ -0,0 +1,245 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface ERC20CustodyInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "withdraw(address,address,uint256)": FunctionFragment; + "withdrawAndCall(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "gateway" | "withdraw" | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: { + "Withdraw(address,address,uint256)": EventFragment; + "WithdrawAndCall(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + token: string; + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ERC20Custody extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ERC20CustodyInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Withdraw(address,address,uint256)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/ERC20CustodyNew.ts b/typechain-types/contracts/prototypes/ERC20CustodyNew.ts new file mode 100644 index 00000000..c2f1889d --- /dev/null +++ b/typechain-types/contracts/prototypes/ERC20CustodyNew.ts @@ -0,0 +1,245 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface ERC20CustodyNewInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "withdraw(address,address,uint256)": FunctionFragment; + "withdrawAndCall(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "gateway" | "withdraw" | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: { + "Withdraw(address,address,uint256)": EventFragment; + "WithdrawAndCall(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + token: string; + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ERC20CustodyNew extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ERC20CustodyNewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Withdraw(address,address,uint256)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/Gateway.ts b/typechain-types/contracts/prototypes/Gateway.ts index 5411e94d..9edf92c6 100644 --- a/typechain-types/contracts/prototypes/Gateway.ts +++ b/typechain-types/contracts/prototypes/Gateway.ts @@ -4,9 +4,11 @@ import type { BaseContract, BigNumber, + BigNumberish, BytesLike, CallOverrides, ContractTransaction, + Overrides, PayableOverrides, PopulatedTransaction, Signer, @@ -28,39 +30,81 @@ import type { export interface GatewayInterface extends utils.Interface { functions: { - "forwardCall(address,bytes)": FunctionFragment; + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "setCustody(address)": FunctionFragment; }; - getFunction(nameOrSignatureOrTopic: "forwardCall"): FunctionFragment; + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "setCustody" + ): FunctionFragment; + encodeFunctionData(functionFragment: "custody", values?: undefined): string; encodeFunctionData( - functionFragment: "forwardCall", + functionFragment: "execute", values: [PromiseOrValue, PromiseOrValue] ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult( - functionFragment: "forwardCall", + functionFragment: "executeWithERC20", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; events: { - "Forwarded(address,uint256,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; }; - getEvent(nameOrSignatureOrTopic: "Forwarded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; } -export interface ForwardedEventObject { +export interface ExecutedEventObject { destination: string; value: BigNumber; data: string; } -export type ForwardedEvent = TypedEvent< +export type ExecutedEvent = TypedEvent< [string, BigNumber, string], - ForwardedEventObject + ExecutedEventObject >; -export type ForwardedEventFilter = TypedEventFilter; +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; export interface Gateway extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; @@ -89,53 +133,141 @@ export interface Gateway extends BaseContract { removeListener: OnEvent; functions: { - forwardCall( + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( destination: PromiseOrValue, data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; - forwardCall( + custody(overrides?: CallOverrides): Promise; + + execute( destination: PromiseOrValue, data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + callStatic: { - forwardCall( + custody(overrides?: CallOverrides): Promise; + + execute( destination: PromiseOrValue, data: PromiseOrValue, overrides?: CallOverrides ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; }; filters: { - "Forwarded(address,uint256,bytes)"( + "Executed(address,uint256,bytes)"( destination?: PromiseOrValue | null, value?: null, data?: null - ): ForwardedEventFilter; - Forwarded( + ): ExecutedEventFilter; + Executed( destination?: PromiseOrValue | null, value?: null, data?: null - ): ForwardedEventFilter; + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; }; estimateGas: { - forwardCall( + custody(overrides?: CallOverrides): Promise; + + execute( destination: PromiseOrValue, data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; populateTransaction: { - forwardCall( + custody(overrides?: CallOverrides): Promise; + + execute( destination: PromiseOrValue, data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; } diff --git a/typechain-types/contracts/prototypes/Receiver.ts b/typechain-types/contracts/prototypes/Receiver.ts index 7bcfec8b..ce0ee82a 100644 --- a/typechain-types/contracts/prototypes/Receiver.ts +++ b/typechain-types/contracts/prototypes/Receiver.ts @@ -32,10 +32,11 @@ export interface ReceiverInterface extends utils.Interface { functions: { "receiveA(string,uint256,bool)": FunctionFragment; "receiveB(string[],uint256[],bool)": FunctionFragment; + "receiveC(uint256,address,address)": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: "receiveA" | "receiveB" + nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" ): FunctionFragment; encodeFunctionData( @@ -54,17 +55,28 @@ export interface ReceiverInterface extends utils.Interface { PromiseOrValue ] ): string; + encodeFunctionData( + functionFragment: "receiveC", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveC", data: BytesLike): Result; events: { "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; "ReceivedB(address,string[],uint256[],bool)": EventFragment; + "ReceivedC(address,uint256,address,address)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedC"): EventFragment; } export interface ReceivedAEventObject { @@ -94,6 +106,19 @@ export type ReceivedBEvent = TypedEvent< export type ReceivedBEventFilter = TypedEventFilter; +export interface ReceivedCEventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedCEvent = TypedEvent< + [string, BigNumber, string, string], + ReceivedCEventObject +>; + +export type ReceivedCEventFilter = TypedEventFilter; + export interface Receiver extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; @@ -134,6 +159,13 @@ export interface Receiver extends BaseContract { flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; receiveA( @@ -150,6 +182,13 @@ export interface Receiver extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + callStatic: { receiveA( str: PromiseOrValue, @@ -164,6 +203,13 @@ export interface Receiver extends BaseContract { flag: PromiseOrValue, overrides?: CallOverrides ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: CallOverrides + ): Promise; }; filters: { @@ -194,6 +240,19 @@ export interface Receiver extends BaseContract { nums?: null, flag?: null ): ReceivedBEventFilter; + + "ReceivedC(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; + ReceivedC( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; }; estimateGas: { @@ -210,6 +269,13 @@ export interface Receiver extends BaseContract { flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; populateTransaction: { @@ -226,5 +292,12 @@ export interface Receiver extends BaseContract { flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; } diff --git a/typechain-types/contracts/prototypes/TestERC20.ts b/typechain-types/contracts/prototypes/TestERC20.ts new file mode 100644 index 00000000..580edbbc --- /dev/null +++ b/typechain-types/contracts/prototypes/TestERC20.ts @@ -0,0 +1,501 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface TestERC20Interface extends utils.Interface { + functions: { + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "decimals()": FunctionFragment; + "decreaseAllowance(address,uint256)": FunctionFragment; + "increaseAllowance(address,uint256)": FunctionFragment; + "mint(address,uint256)": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "allowance" + | "approve" + | "balanceOf" + | "decimals" + | "decreaseAllowance" + | "increaseAllowance" + | "mint" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "decreaseAllowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "increaseAllowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "mint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "decreaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "increaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface TestERC20 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: TestERC20Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + }; + + estimateGas: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index 993ba38c..420d0e89 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -1,5 +1,7 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { Gateway } from "./Gateway"; export type { Receiver } from "./Receiver"; +export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts new file mode 100644 index 00000000..09f746f5 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -0,0 +1,196 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + ERC20CustodyNew, + ERC20CustodyNewInterface, +} from "../../../contracts/prototypes/ERC20CustodyNew"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract Gateway", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ERC20CustodyNewConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ERC20CustodyNewConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ERC20CustodyNew__factory extends ContractFactory { + constructor(...args: ERC20CustodyNewConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(_gateway, overrides || {}) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, overrides || {}); + } + override attach(address: string): ERC20CustodyNew { + return super.attach(address) as ERC20CustodyNew; + } + override connect(signer: Signer): ERC20CustodyNew__factory { + return super.connect(signer) as ERC20CustodyNew__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ERC20CustodyNewInterface { + return new utils.Interface(_abi) as ERC20CustodyNewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ERC20CustodyNew { + return new Contract(address, _abi, signerOrProvider) as ERC20CustodyNew; + } +} diff --git a/typechain-types/factories/contracts/prototypes/ERC20Custody__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20Custody__factory.ts new file mode 100644 index 00000000..ab89fca7 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/ERC20Custody__factory.ts @@ -0,0 +1,196 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + ERC20Custody, + ERC20CustodyInterface, +} from "../../../contracts/prototypes/ERC20Custody"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract Gateway", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ERC20CustodyConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ERC20CustodyConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ERC20Custody__factory extends ContractFactory { + constructor(...args: ERC20CustodyConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(_gateway, overrides || {}) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, overrides || {}); + } + override attach(address: string): ERC20Custody { + return super.attach(address) as ERC20Custody; + } + override connect(signer: Signer): ERC20Custody__factory { + return super.connect(signer) as ERC20Custody__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ERC20CustodyInterface { + return new utils.Interface(_abi) as ERC20CustodyInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ERC20Custody { + return new Contract(address, _abi, signerOrProvider) as ERC20Custody; + } +} diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 174c824e..9c2bbad3 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -32,9 +32,53 @@ const _abi = [ type: "bytes", }, ], - name: "Forwarded", + name: "Executed", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "contract ERC20CustodyNew", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, { inputs: [ { @@ -48,7 +92,7 @@ const _abi = [ type: "bytes", }, ], - name: "forwardCall", + name: "execute", outputs: [ { internalType: "bytes", @@ -59,10 +103,57 @@ const _abi = [ stateMutability: "payable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts index e86bc2fd..5c7c7429 100644 --- a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts @@ -78,6 +78,37 @@ const _abi = [ name: "ReceivedB", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedC", + type: "event", + }, { inputs: [ { @@ -124,10 +155,33 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "receiveC", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type ReceiverConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/TestERC20__factory.ts b/typechain-types/factories/contracts/prototypes/TestERC20__factory.ts new file mode 100644 index 00000000..f5181c5f --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/TestERC20__factory.ts @@ -0,0 +1,371 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + TestERC20, + TestERC20Interface, +} from "../../../contracts/prototypes/TestERC20"; + +const _abi = [ + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "symbol", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "subtractedValue", + type: "uint256", + }, + ], + name: "decreaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "addedValue", + type: "uint256", + }, + ], + name: "increaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "mint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type TestERC20ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: TestERC20ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class TestERC20__factory extends ContractFactory { + constructor(...args: TestERC20ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + name: PromiseOrValue, + symbol: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(name, symbol, overrides || {}) as Promise; + } + override getDeployTransaction( + name: PromiseOrValue, + symbol: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(name, symbol, overrides || {}); + } + override attach(address: string): TestERC20 { + return super.attach(address) as TestERC20; + } + override connect(signer: Signer): TestERC20__factory { + return super.connect(signer) as TestERC20__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): TestERC20Interface { + return new utils.Interface(_abi) as TestERC20Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): TestERC20 { + return new Contract(address, _abi, signerOrProvider) as TestERC20; + } +} diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 28689ac1..9dfdd555 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -1,5 +1,7 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { Gateway__factory } from "./Gateway__factory"; export { Receiver__factory } from "./Receiver__factory"; +export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 086156ef..06d7d730 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -300,6 +300,10 @@ declare module "hardhat/types/runtime" { name: "ZetaConnectorNonEth", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ERC20CustodyNew", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "Gateway", signerOrOptions?: ethers.Signer | FactoryOptions @@ -308,6 +312,10 @@ declare module "hardhat/types/runtime" { name: "Receiver", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "TestERC20", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -737,6 +745,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ERC20CustodyNew", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "Gateway", address: string, @@ -747,6 +760,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "TestERC20", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 8ee5ddbc..7ad48bc2 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -140,10 +140,14 @@ export type { ZetaConnectorEth } from "./contracts/evm/ZetaConnector.eth.sol/Zet export { ZetaConnectorEth__factory } from "./factories/contracts/evm/ZetaConnector.eth.sol/ZetaConnectorEth__factory"; export type { ZetaConnectorNonEth } from "./contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth"; export { ZetaConnectorNonEth__factory } from "./factories/contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth__factory"; +export type { ERC20CustodyNew } from "./contracts/prototypes/ERC20CustodyNew"; +export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/ERC20CustodyNew__factory"; export type { Gateway } from "./contracts/prototypes/Gateway"; export { Gateway__factory } from "./factories/contracts/prototypes/Gateway__factory"; export type { Receiver } from "./contracts/prototypes/Receiver"; export { Receiver__factory } from "./factories/contracts/prototypes/Receiver__factory"; +export type { TestERC20 } from "./contracts/prototypes/TestERC20"; +export { TestERC20__factory } from "./factories/contracts/prototypes/TestERC20__factory"; export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; From 484096aeefb071a08805807b2a4e67989c577f78 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 14:00:31 +0200 Subject: [PATCH 11/86] add some more tests --- contracts/prototypes/Receiver.sol | 9 +++++ test/prototypes/GatewayIntegration.spec.ts | 40 ++++++++++++++++++- .../contracts/prototypes/Receiver.ts | 35 +++++++++++++++- .../contracts/prototypes/Receiver__factory.ts | 22 +++++++++- 4 files changed, 103 insertions(+), 3 deletions(-) diff --git a/contracts/prototypes/Receiver.sol b/contracts/prototypes/Receiver.sol index 0fc941d0..f25a1932 100644 --- a/contracts/prototypes/Receiver.sol +++ b/contracts/prototypes/Receiver.sol @@ -7,19 +7,28 @@ contract Receiver { event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); event ReceivedC(address sender, uint256 amount, address token, address destination); + event ReceivedD(address sender); + // Payable function function receiveA(string memory str, uint256 num, bool flag) external payable { emit ReceivedA(msg.sender, msg.value, str, num, flag); } + // Non-payable function function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external { emit ReceivedB(msg.sender, strs, nums, flag); } + // Function using IERC20 function receiveC(uint256 amount, address token, address destination) external { // Transfer tokens from the Gateway contract to the destination address IERC20(token).transferFrom(msg.sender, destination, amount); emit ReceivedC(msg.sender, amount, token, destination); } + + // Function without parameters + function receiveD() external { + emit ReceivedD(msg.sender); + } } \ No newline at end of file diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index b0d07669..40917f2e 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -65,7 +65,11 @@ describe("Gateway and Receiver", function () { const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); // Withdraw and call - await custody.withdrawAndCall(token.address, receiver.address, amount, data); + const tx = await custody.withdrawAndCall(token.address, receiver.address, amount, data); + await tx.wait(); + + // Verify the event was emitted + await expect(tx).to.emit(receiver, "ReceivedC").withArgs(gateway.address, amount, token.address, destination.address); // Verify that the tokens were transferred to the destination address const receiverBalance = await token.balanceOf(destination.address); @@ -79,4 +83,38 @@ describe("Gateway and Receiver", function () { const allowance = await token.allowance(gateway.address, receiver.address); expect(allowance).to.equal(0); }); + + it("should forward call to Receiver's receiveD function", async function () { + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Execute the call + const tx = await gateway.execute(receiver.address, data); + await tx.wait(); + + // Verify the event was emitted + await expect(tx).to.emit(receiver, "ReceivedD").withArgs(gateway.address) + }); + + it("should forward call to Receiver's receiveD function through withdrawAndCall and return ERC20 tokens to custody", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveD + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Withdraw and call + await custody.withdrawAndCall(token.address, receiver.address, amount, data); + + // Verify the event was emitted + await expect(custody.withdrawAndCall(token.address, receiver.address, amount, data)) + .to.emit(receiver, "ReceivedD") + .withArgs(gateway.address); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("500")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); }); \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/Receiver.ts b/typechain-types/contracts/prototypes/Receiver.ts index ce0ee82a..4e82b83e 100644 --- a/typechain-types/contracts/prototypes/Receiver.ts +++ b/typechain-types/contracts/prototypes/Receiver.ts @@ -33,10 +33,11 @@ export interface ReceiverInterface extends utils.Interface { "receiveA(string,uint256,bool)": FunctionFragment; "receiveB(string[],uint256[],bool)": FunctionFragment; "receiveC(uint256,address,address)": FunctionFragment; + "receiveD()": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" + nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" | "receiveD" ): FunctionFragment; encodeFunctionData( @@ -63,20 +64,24 @@ export interface ReceiverInterface extends utils.Interface { PromiseOrValue ] ): string; + encodeFunctionData(functionFragment: "receiveD", values?: undefined): string; decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; decodeFunctionResult(functionFragment: "receiveC", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveD", data: BytesLike): Result; events: { "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; "ReceivedB(address,string[],uint256[],bool)": EventFragment; "ReceivedC(address,uint256,address,address)": EventFragment; + "ReceivedD(address)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; getEvent(nameOrSignatureOrTopic: "ReceivedC"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedD"): EventFragment; } export interface ReceivedAEventObject { @@ -119,6 +124,13 @@ export type ReceivedCEvent = TypedEvent< export type ReceivedCEventFilter = TypedEventFilter; +export interface ReceivedDEventObject { + sender: string; +} +export type ReceivedDEvent = TypedEvent<[string], ReceivedDEventObject>; + +export type ReceivedDEventFilter = TypedEventFilter; + export interface Receiver extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; @@ -166,6 +178,10 @@ export interface Receiver extends BaseContract { destination: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; receiveA( @@ -189,6 +205,10 @@ export interface Receiver extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + callStatic: { receiveA( str: PromiseOrValue, @@ -210,6 +230,8 @@ export interface Receiver extends BaseContract { destination: PromiseOrValue, overrides?: CallOverrides ): Promise; + + receiveD(overrides?: CallOverrides): Promise; }; filters: { @@ -253,6 +275,9 @@ export interface Receiver extends BaseContract { token?: null, destination?: null ): ReceivedCEventFilter; + + "ReceivedD(address)"(sender?: null): ReceivedDEventFilter; + ReceivedD(sender?: null): ReceivedDEventFilter; }; estimateGas: { @@ -276,6 +301,10 @@ export interface Receiver extends BaseContract { destination: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; populateTransaction: { @@ -299,5 +328,9 @@ export interface Receiver extends BaseContract { destination: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; }; } diff --git a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts index 5c7c7429..bd3f76e9 100644 --- a/typechain-types/factories/contracts/prototypes/Receiver__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Receiver__factory.ts @@ -109,6 +109,19 @@ const _abi = [ name: "ReceivedC", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedD", + type: "event", + }, { inputs: [ { @@ -178,10 +191,17 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "receiveD", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type ReceiverConstructorParams = | [signer?: Signer] From a0c8e5a5248965ebe7b5ff34dc4970dab1cf0d67 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 15:42:42 +0200 Subject: [PATCH 12/86] initalize uniswap test --- test/prototypes/GatewayUniswap.spec.ts | 97 ++++ typechain-types/contracts/prototypes/WETH9.ts | 480 ++++++++++++++++++ .../contracts/prototypes/WETH9__factory.ts | 340 +++++++++++++ 3 files changed, 917 insertions(+) create mode 100644 test/prototypes/GatewayUniswap.spec.ts create mode 100644 typechain-types/contracts/prototypes/WETH9.ts create mode 100644 typechain-types/factories/contracts/prototypes/WETH9__factory.ts diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts new file mode 100644 index 00000000..fe340c69 --- /dev/null +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -0,0 +1,97 @@ +import { expect } from "chai"; +import { Contract } from "ethers"; +import { ethers } from "hardhat"; +import { ERC20, ERC20CustodyNew, Gateway, Receiver, TestERC20, UniswapV2Factory, UniswapV2Pair, UniswapV2Router02 } from "../../typechain-types"; + +describe("Uniswap Integration with Gateway", function () { + let tokenA: TestERC20; + let tokenB: TestERC20; + let factory: UniswapV2Factory; + let router: UniswapV2Router02; + let pair: UniswapV2Pair; + let custody: ERC20CustodyNew; + let gateway: Gateway; + let receiver: Receiver; + let owner, addr1, addr2; + + beforeEach(async function () { + [owner, addr1, addr2] = await ethers.getSigners(); + + // Deploy TestERC20 tokens + const TestERC20 = await ethers.getContractFactory("TestERC20"); + tokenA = await TestERC20.deploy("Token A", "TKA") as TestERC20; + tokenB = await TestERC20.deploy("Token B", "TKB") as TestERC20; + await tokenA.mint(owner.address, ethers.utils.parseEther("1000")); + await tokenB.mint(owner.address, ethers.utils.parseEther("1000")); + + // Deploy Uniswap Factory + const UniswapV2Factory = await ethers.getContractFactory("@uniswap/v2-core/contracts/UniswapV2Factory.sol:UniswapV2Factory"); + factory = await UniswapV2Factory.deploy(owner.address) as UniswapV2Factory; + + // Deploy Uniswap Router + const UniswapV2Router02 = await ethers.getContractFactory("@uniswap/v2-periphery/contracts/UniswapV2Router02.sol:UniswapV2Router02"); + const WETH = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9"); + const weth = await WETH.deploy(); + router = await UniswapV2Router02.deploy(factory.address, weth.address) as UniswapV2Router02; + + // Approve Router to move tokens + await tokenA.approve(router.address, ethers.utils.parseEther("1000")); + await tokenB.approve(router.address, ethers.utils.parseEther("1000")); + + // Create Uniswap Pair + await factory.createPair(tokenA.address, tokenB.address); + + const pairAddress = await factory.getPair(tokenA.address, tokenB.address); + pair = await ethers.getContractAt("UniswapV2Pair", pairAddress) as UniswapV2Pair; + + // Add Liquidity + await router.addLiquidity( + tokenA.address, + tokenB.address, + ethers.utils.parseEther("500"), + ethers.utils.parseEther("500"), + 0, + 0, + owner.address, + Math.floor(Date.now() / 1000) + 60 * 20 + ); + + // Deploy Gateway and Custody Contracts + const Gateway = await ethers.getContractFactory("Gateway"); + const ERC20Custody = await ethers.getContractFactory("ERC20Custody"); + const Receiver = await ethers.getContractFactory("Receiver"); + gateway = await Gateway.deploy(addr1.address) as Gateway; + custody = await ERC20Custody.deploy(gateway.address) as ERC20CustodyNew; + receiver = await Receiver.deploy() as Receiver; + + // Transfer some tokens to the custody contract + await tokenA.transfer(custody.address, ethers.utils.parseEther("100")); + await tokenB.transfer(custody.address, ethers.utils.parseEther("100")); + }); + + it("should perform a token swap on Uniswap and transfer the output tokens to a destination address", async function () { + const amountIn = ethers.utils.parseEther("50"); + const data = router.interface.encodeFunctionData("swapExactTokensForTokens", [ + amountIn, + 0, + [tokenA.address, tokenB.address], + addr2.address, + Math.floor(Date.now() / 1000) + 60 * 20 + ]); + + // Withdraw and call + await custody.withdrawAndCall(tokenA.address, router.address, amountIn, data); + + // Verify the destination address received the tokens + const destBalance = await tokenB.balanceOf(addr2.address); + expect(destBalance).to.be.gt(0); + + // Verify the remaining tokens are refunded to the Custody contract + const remainingBalance = await tokenA.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("50")); + + // Verify the approval was reset + const allowance = await tokenA.allowance(gateway.address, router.address); + expect(allowance).to.equal(0); + }); +}); \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/WETH9.ts b/typechain-types/contracts/prototypes/WETH9.ts new file mode 100644 index 00000000..cc4355f3 --- /dev/null +++ b/typechain-types/contracts/prototypes/WETH9.ts @@ -0,0 +1,480 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface WETH9Interface extends utils.Interface { + functions: { + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "decimals()": FunctionFragment; + "deposit()": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + "withdraw(uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "allowance" + | "approve" + | "balanceOf" + | "decimals" + | "deposit" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + | "withdraw" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData(functionFragment: "deposit", values?: undefined): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Deposit(address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + "Withdrawal(address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface ApprovalEventObject { + src: string; + guy: string; + wad: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface DepositEventObject { + dst: string; + wad: BigNumber; +} +export type DepositEvent = TypedEvent<[string, BigNumber], DepositEventObject>; + +export type DepositEventFilter = TypedEventFilter; + +export interface TransferEventObject { + src: string; + dst: string; + wad: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + src: string; + wad: BigNumber; +} +export type WithdrawalEvent = TypedEvent< + [string, BigNumber], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface WETH9 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: WETH9Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + allowance( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + guy: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + deposit( + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + src: PromiseOrValue, + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + allowance( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + guy: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + src: PromiseOrValue, + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + allowance( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + guy: PromiseOrValue, + wad: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit(overrides?: CallOverrides): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + src: PromiseOrValue, + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + wad: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + src?: PromiseOrValue | null, + guy?: PromiseOrValue | null, + wad?: null + ): ApprovalEventFilter; + Approval( + src?: PromiseOrValue | null, + guy?: PromiseOrValue | null, + wad?: null + ): ApprovalEventFilter; + + "Deposit(address,uint256)"( + dst?: PromiseOrValue | null, + wad?: null + ): DepositEventFilter; + Deposit( + dst?: PromiseOrValue | null, + wad?: null + ): DepositEventFilter; + + "Transfer(address,address,uint256)"( + src?: PromiseOrValue | null, + dst?: PromiseOrValue | null, + wad?: null + ): TransferEventFilter; + Transfer( + src?: PromiseOrValue | null, + dst?: PromiseOrValue | null, + wad?: null + ): TransferEventFilter; + + "Withdrawal(address,uint256)"( + src?: PromiseOrValue | null, + wad?: null + ): WithdrawalEventFilter; + Withdrawal( + src?: PromiseOrValue | null, + wad?: null + ): WithdrawalEventFilter; + }; + + estimateGas: { + allowance( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + guy: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + src: PromiseOrValue, + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + allowance( + arg0: PromiseOrValue, + arg1: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + guy: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + src: PromiseOrValue, + dst: PromiseOrValue, + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + wad: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/factories/contracts/prototypes/WETH9__factory.ts b/typechain-types/factories/contracts/prototypes/WETH9__factory.ts new file mode 100644 index 00000000..756734af --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/WETH9__factory.ts @@ -0,0 +1,340 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + WETH9, + WETH9Interface, +} from "../../../contracts/prototypes/WETH9"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "src", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "guy", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "dst", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "src", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "dst", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "src", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "guy", + type: "address", + }, + { + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "dst", + type: "address", + }, + { + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "src", + type: "address", + }, + { + internalType: "address", + name: "dst", + type: "address", + }, + { + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "wad", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type WETH9ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: WETH9ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class WETH9__factory extends ContractFactory { + constructor(...args: WETH9ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): WETH9 { + return super.attach(address) as WETH9; + } + override connect(signer: Signer): WETH9__factory { + return super.connect(signer) as WETH9__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): WETH9Interface { + return new utils.Interface(_abi) as WETH9Interface; + } + static connect(address: string, signerOrProvider: Signer | Provider): WETH9 { + return new Contract(address, _abi, signerOrProvider) as WETH9; + } +} From 5b893d29f2d58bba18ef9b1ae1fc4ac4b387aaf6 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 16:57:51 +0200 Subject: [PATCH 13/86] finish test for uniswap --- hardhat.config.ts | 1 + package.json | 3 ++- test/prototypes/GatewayUniswap.spec.ts | 34 +++++++++++--------------- yarn.lock | 16 +++++++++++- 4 files changed, 32 insertions(+), 22 deletions(-) diff --git a/hardhat.config.ts b/hardhat.config.ts index bbf4aef7..36929410 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -3,6 +3,7 @@ import "@nomicfoundation/hardhat-verify"; import "@typechain/hardhat"; import "tsconfig-paths/register"; import "hardhat-abi-exporter"; +import "uniswap-v2-deploy-plugin"; import "./tasks/addresses"; import { getHardhatConfigNetworks } from "@zetachain/networks"; diff --git a/package.json b/package.json index fb5697be..34f14f00 100644 --- a/package.json +++ b/package.json @@ -53,7 +53,8 @@ "ts-node": "10.8.1", "tsconfig-paths": "^3.14.1", "typechain": "^8.1.0", - "typescript": "^4.6.3" + "typescript": "^4.6.3", + "uniswap-v2-deploy-plugin": "^0.0.4" }, "files": [ "contracts", diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index fe340c69..909a52cf 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -2,6 +2,7 @@ import { expect } from "chai"; import { Contract } from "ethers"; import { ethers } from "hardhat"; import { ERC20, ERC20CustodyNew, Gateway, Receiver, TestERC20, UniswapV2Factory, UniswapV2Pair, UniswapV2Router02 } from "../../typechain-types"; +import { UniswapV2Deployer } from "uniswap-v2-deploy-plugin"; describe("Uniswap Integration with Gateway", function () { let tokenA: TestERC20; @@ -11,7 +12,6 @@ describe("Uniswap Integration with Gateway", function () { let pair: UniswapV2Pair; let custody: ERC20CustodyNew; let gateway: Gateway; - let receiver: Receiver; let owner, addr1, addr2; beforeEach(async function () { @@ -24,25 +24,20 @@ describe("Uniswap Integration with Gateway", function () { await tokenA.mint(owner.address, ethers.utils.parseEther("1000")); await tokenB.mint(owner.address, ethers.utils.parseEther("1000")); - // Deploy Uniswap Factory - const UniswapV2Factory = await ethers.getContractFactory("@uniswap/v2-core/contracts/UniswapV2Factory.sol:UniswapV2Factory"); - factory = await UniswapV2Factory.deploy(owner.address) as UniswapV2Factory; - - // Deploy Uniswap Router - const UniswapV2Router02 = await ethers.getContractFactory("@uniswap/v2-periphery/contracts/UniswapV2Router02.sol:UniswapV2Router02"); - const WETH = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9"); - const weth = await WETH.deploy(); - router = await UniswapV2Router02.deploy(factory.address, weth.address) as UniswapV2Router02; + + const { + factory: newFactory, + router: newRouter, + weth9: weth + } = await UniswapV2Deployer.deploy(owner) + + factory = newFactory; + router = newRouter; // Approve Router to move tokens await tokenA.approve(router.address, ethers.utils.parseEther("1000")); await tokenB.approve(router.address, ethers.utils.parseEther("1000")); - // Create Uniswap Pair - await factory.createPair(tokenA.address, tokenB.address); - - const pairAddress = await factory.getPair(tokenA.address, tokenB.address); - pair = await ethers.getContractAt("UniswapV2Pair", pairAddress) as UniswapV2Pair; // Add Liquidity await router.addLiquidity( @@ -58,11 +53,9 @@ describe("Uniswap Integration with Gateway", function () { // Deploy Gateway and Custody Contracts const Gateway = await ethers.getContractFactory("Gateway"); - const ERC20Custody = await ethers.getContractFactory("ERC20Custody"); - const Receiver = await ethers.getContractFactory("Receiver"); - gateway = await Gateway.deploy(addr1.address) as Gateway; - custody = await ERC20Custody.deploy(gateway.address) as ERC20CustodyNew; - receiver = await Receiver.deploy() as Receiver; + const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); + gateway = await Gateway.deploy() as Gateway; + custody = await ERC20CustodyNew.deploy(gateway.address) as ERC20CustodyNew; // Transfer some tokens to the custody contract await tokenA.transfer(custody.address, ethers.utils.parseEther("100")); @@ -71,6 +64,7 @@ describe("Uniswap Integration with Gateway", function () { it("should perform a token swap on Uniswap and transfer the output tokens to a destination address", async function () { const amountIn = ethers.utils.parseEther("50"); + const data = router.interface.encodeFunctionData("swapExactTokensForTokens", [ amountIn, 0, diff --git a/yarn.lock b/yarn.lock index a7173b15..9cacd76e 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1539,6 +1539,11 @@ resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-3.4.2-solc-0.7.tgz#38f4dbab672631034076ccdf2f3201fab1726635" integrity sha512-W6QmqgkADuFcTLzHL8vVoNBtkwjvQRpYIAom7KiUNoLKghyx3FgH0GBjt8NRvigV1ZmMOBllvE1By1C+bi8WpA== +"@openzeppelin/contracts@^4.3.2": + version "4.9.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.9.6.tgz#2a880a24eb19b4f8b25adc2a5095f2aa27f39677" + integrity sha512-xSmezSupL+y9VkHZJGDoCBpmnB2ogM13ccaYDWqJTfS3dbuHkgjuwDFUmaFauBCboQMGB/S5UqUl2y54X99BmA== + "@openzeppelin/contracts@^4.8.3": version "4.8.3" resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.8.3.tgz#cbef3146bfc570849405f59cba18235da95a252a" @@ -2054,7 +2059,7 @@ resolved "https://registry.yarnpkg.com/@uniswap/v2-core/-/v2-core-1.0.1.tgz#af8f508bf183204779938969e2e54043e147d425" integrity sha512-MtybtkUPSyysqLY2U210NBDeCHX+ltHt3oADGdjqoThZaFRDKwM6k1Nb3F0A3hk5hwuQvytFWhrWHOEq6nVJ8Q== -"@uniswap/v2-periphery@^1.1.0-beta.0": +"@uniswap/v2-periphery@1.1.0-beta.0", "@uniswap/v2-periphery@^1.1.0-beta.0": version "1.1.0-beta.0" resolved "https://registry.yarnpkg.com/@uniswap/v2-periphery/-/v2-periphery-1.1.0-beta.0.tgz#20a4ccfca22f1a45402303aedb5717b6918ebe6d" integrity sha512-6dkwAMKza8nzqYiXEr2D86dgW3TTavUvCR0w2Tu33bAbM8Ah43LKAzH7oKKPRT5VJQaMi1jtkGs1E8JPor1n5g== @@ -8681,6 +8686,15 @@ union-value@^1.0.0: is-extendable "^0.1.1" set-value "^2.0.1" +uniswap-v2-deploy-plugin@^0.0.4: + version "0.0.4" + resolved "https://registry.yarnpkg.com/uniswap-v2-deploy-plugin/-/uniswap-v2-deploy-plugin-0.0.4.tgz#9eeb1e48ecd3f02b195210fd1eebbe624ee87ad9" + integrity sha512-4+1tfxul77SedONq1hwQixF2vwH/zy9KLj9XcA3QYPN5SUcp5ZgGYZFxPAmZJOEDAAWBz2oHJT26oLjbyuZrVg== + dependencies: + "@openzeppelin/contracts" "^4.3.2" + "@uniswap/v2-core" "^1.0.1" + "@uniswap/v2-periphery" "1.1.0-beta.0" + universalify@^0.1.0: version "0.1.2" resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66" From 776caefbb33d7b1efe1f94ac4771d417dd3da2c6 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 17:19:21 +0200 Subject: [PATCH 14/86] generate --- .../erc20custodynew.sol/erc20custodynew.go | 585 +++++++++++++ .../prototypes/gateway.sol/gateway.go | 308 ++++++- .../prototypes/receiver.sol/receiver.go | 317 ++++++- .../prototypes/testerc20.sol/testerc20.go | 823 ++++++++++++++++++ test/prototypes/GatewayIntegration.spec.ts | 232 ++--- test/prototypes/GatewayUniswap.spec.ts | 174 ++-- 6 files changed, 2197 insertions(+), 242 deletions(-) create mode 100644 pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go create mode 100644 pkg/contracts/prototypes/testerc20.sol/testerc20.go diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go new file mode 100644 index 00000000..0e921cd7 --- /dev/null +++ b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go @@ -0,0 +1,585 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package erc20custodynew + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. +var ERC20CustodyNewMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// ERC20CustodyNewABI is the input ABI used to generate the binding from. +// Deprecated: Use ERC20CustodyNewMetaData.ABI instead. +var ERC20CustodyNewABI = ERC20CustodyNewMetaData.ABI + +// ERC20CustodyNewBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ERC20CustodyNewMetaData.Bin instead. +var ERC20CustodyNewBin = ERC20CustodyNewMetaData.Bin + +// DeployERC20CustodyNew deploys a new Ethereum contract, binding an instance of ERC20CustodyNew to it. +func DeployERC20CustodyNew(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address) (common.Address, *types.Transaction, *ERC20CustodyNew, error) { + parsed, err := ERC20CustodyNewMetaData.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(ERC20CustodyNewBin), backend, _gateway) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ERC20CustodyNew{ERC20CustodyNewCaller: ERC20CustodyNewCaller{contract: contract}, ERC20CustodyNewTransactor: ERC20CustodyNewTransactor{contract: contract}, ERC20CustodyNewFilterer: ERC20CustodyNewFilterer{contract: contract}}, nil +} + +// ERC20CustodyNew is an auto generated Go binding around an Ethereum contract. +type ERC20CustodyNew struct { + ERC20CustodyNewCaller // Read-only binding to the contract + ERC20CustodyNewTransactor // Write-only binding to the contract + ERC20CustodyNewFilterer // Log filterer for contract events +} + +// ERC20CustodyNewCaller is an auto generated read-only Go binding around an Ethereum contract. +type ERC20CustodyNewCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ERC20CustodyNewTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ERC20CustodyNewFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ERC20CustodyNewSession struct { + Contract *ERC20CustodyNew // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20CustodyNewCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ERC20CustodyNewCallerSession struct { + Contract *ERC20CustodyNewCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ERC20CustodyNewTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ERC20CustodyNewTransactorSession struct { + Contract *ERC20CustodyNewTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20CustodyNewRaw is an auto generated low-level Go binding around an Ethereum contract. +type ERC20CustodyNewRaw struct { + Contract *ERC20CustodyNew // Generic contract binding to access the raw methods on +} + +// ERC20CustodyNewCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ERC20CustodyNewCallerRaw struct { + Contract *ERC20CustodyNewCaller // Generic read-only contract binding to access the raw methods on +} + +// ERC20CustodyNewTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ERC20CustodyNewTransactorRaw struct { + Contract *ERC20CustodyNewTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewERC20CustodyNew creates a new instance of ERC20CustodyNew, bound to a specific deployed contract. +func NewERC20CustodyNew(address common.Address, backend bind.ContractBackend) (*ERC20CustodyNew, error) { + contract, err := bindERC20CustodyNew(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ERC20CustodyNew{ERC20CustodyNewCaller: ERC20CustodyNewCaller{contract: contract}, ERC20CustodyNewTransactor: ERC20CustodyNewTransactor{contract: contract}, ERC20CustodyNewFilterer: ERC20CustodyNewFilterer{contract: contract}}, nil +} + +// NewERC20CustodyNewCaller creates a new read-only instance of ERC20CustodyNew, bound to a specific deployed contract. +func NewERC20CustodyNewCaller(address common.Address, caller bind.ContractCaller) (*ERC20CustodyNewCaller, error) { + contract, err := bindERC20CustodyNew(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ERC20CustodyNewCaller{contract: contract}, nil +} + +// NewERC20CustodyNewTransactor creates a new write-only instance of ERC20CustodyNew, bound to a specific deployed contract. +func NewERC20CustodyNewTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20CustodyNewTransactor, error) { + contract, err := bindERC20CustodyNew(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ERC20CustodyNewTransactor{contract: contract}, nil +} + +// NewERC20CustodyNewFilterer creates a new log filterer instance of ERC20CustodyNew, bound to a specific deployed contract. +func NewERC20CustodyNewFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20CustodyNewFilterer, error) { + contract, err := bindERC20CustodyNew(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ERC20CustodyNewFilterer{contract: contract}, nil +} + +// bindERC20CustodyNew binds a generic wrapper to an already deployed contract. +func bindERC20CustodyNew(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ERC20CustodyNewMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20CustodyNew *ERC20CustodyNewRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC20CustodyNew.Contract.ERC20CustodyNewCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20CustodyNew *ERC20CustodyNewRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.ERC20CustodyNewTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20CustodyNew *ERC20CustodyNewRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.ERC20CustodyNewTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20CustodyNew *ERC20CustodyNewCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC20CustodyNew.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20CustodyNew *ERC20CustodyNewTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20CustodyNew *ERC20CustodyNewTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNew *ERC20CustodyNewCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ERC20CustodyNew.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNew *ERC20CustodyNewSession) Gateway() (common.Address, error) { + return _ERC20CustodyNew.Contract.Gateway(&_ERC20CustodyNew.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNew *ERC20CustodyNewCallerSession) Gateway() (common.Address, error) { + return _ERC20CustodyNew.Contract.Gateway(&_ERC20CustodyNew.CallOpts) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNew *ERC20CustodyNewTransactor) Withdraw(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNew.contract.Transact(opts, "withdraw", token, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNew *ERC20CustodyNewSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.Withdraw(&_ERC20CustodyNew.TransactOpts, token, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNew *ERC20CustodyNewTransactorSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.Withdraw(&_ERC20CustodyNew.TransactOpts, token, to, amount) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNew *ERC20CustodyNewTransactor) WithdrawAndCall(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNew.contract.Transact(opts, "withdrawAndCall", token, to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNew *ERC20CustodyNewSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.WithdrawAndCall(&_ERC20CustodyNew.TransactOpts, token, to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNew *ERC20CustodyNewTransactorSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNew.Contract.WithdrawAndCall(&_ERC20CustodyNew.TransactOpts, token, to, amount, data) +} + +// ERC20CustodyNewWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ERC20CustodyNew contract. +type ERC20CustodyNewWithdrawIterator struct { + Event *ERC20CustodyNewWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20CustodyNewWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20CustodyNewWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20CustodyNewWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20CustodyNewWithdraw represents a Withdraw event raised by the ERC20CustodyNew contract. +type ERC20CustodyNewWithdraw struct { + Token common.Address + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) FilterWithdraw(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewWithdrawIterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNew.contract.FilterLogs(opts, "Withdraw", tokenRule, toRule) + if err != nil { + return nil, err + } + return &ERC20CustodyNewWithdrawIterator{contract: _ERC20CustodyNew.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewWithdraw, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNew.contract.WatchLogs(opts, "Withdraw", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20CustodyNewWithdraw) + if err := _ERC20CustodyNew.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) ParseWithdraw(log types.Log) (*ERC20CustodyNewWithdraw, error) { + event := new(ERC20CustodyNewWithdraw) + if err := _ERC20CustodyNew.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ERC20CustodyNewWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ERC20CustodyNew contract. +type ERC20CustodyNewWithdrawAndCallIterator struct { + Event *ERC20CustodyNewWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20CustodyNewWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20CustodyNewWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20CustodyNewWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20CustodyNewWithdrawAndCall represents a WithdrawAndCall event raised by the ERC20CustodyNew contract. +type ERC20CustodyNewWithdrawAndCall struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewWithdrawAndCallIterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNew.contract.FilterLogs(opts, "WithdrawAndCall", tokenRule, toRule) + if err != nil { + return nil, err + } + return &ERC20CustodyNewWithdrawAndCallIterator{contract: _ERC20CustodyNew.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewWithdrawAndCall, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNew.contract.WatchLogs(opts, "WithdrawAndCall", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20CustodyNewWithdrawAndCall) + if err := _ERC20CustodyNew.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNew *ERC20CustodyNewFilterer) ParseWithdrawAndCall(log types.Log) (*ERC20CustodyNewWithdrawAndCall, error) { + event := new(ERC20CustodyNewWithdrawAndCall) + if err := _ERC20CustodyNew.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index 5d4d40ff..8615305f 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -31,8 +31,8 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Forwarded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"forwardCall\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. @@ -202,30 +202,103 @@ func (_Gateway *GatewayTransactorRaw) Transact(opts *bind.TransactOpts, method s return _Gateway.Contract.contract.Transact(opts, method, params...) } -// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// Custody is a free data retrieval call binding the contract method 0xdda79b75. // -// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewayTransactor) ForwardCall(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "forwardCall", destination, data) +// Solidity: function custody() view returns(address) +func (_Gateway *GatewayCaller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Gateway.contract.Call(opts, &out, "custody") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + } -// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// Custody is a free data retrieval call binding the contract method 0xdda79b75. // -// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewaySession) ForwardCall(destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.ForwardCall(&_Gateway.TransactOpts, destination, data) +// Solidity: function custody() view returns(address) +func (_Gateway *GatewaySession) Custody() (common.Address, error) { + return _Gateway.Contract.Custody(&_Gateway.CallOpts) } -// ForwardCall is a paid mutator transaction binding the contract method 0x22bee494. +// Custody is a free data retrieval call binding the contract method 0xdda79b75. // -// Solidity: function forwardCall(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewayTransactorSession) ForwardCall(destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.ForwardCall(&_Gateway.TransactOpts, destination, data) +// Solidity: function custody() view returns(address) +func (_Gateway *GatewayCallerSession) Custody() (common.Address, error) { + return _Gateway.Contract.Custody(&_Gateway.CallOpts) } -// GatewayForwardedIterator is returned from FilterForwarded and is used to iterate over the raw logs and unpacked data for Forwarded events raised by the Gateway contract. -type GatewayForwardedIterator struct { - Event *GatewayForwarded // Event containing the contract specifics and raw log +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewayTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewaySession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.Execute(&_Gateway.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_Gateway *GatewayTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.Execute(&_Gateway.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_Gateway *GatewayTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_Gateway *GatewaySession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.ExecuteWithERC20(&_Gateway.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_Gateway *GatewayTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.ExecuteWithERC20(&_Gateway.TransactOpts, token, to, amount, data) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_Gateway *GatewayTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_Gateway *GatewaySession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _Gateway.Contract.SetCustody(&_Gateway.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_Gateway *GatewayTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _Gateway.Contract.SetCustody(&_Gateway.TransactOpts, _custody) +} + +// GatewayExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the Gateway contract. +type GatewayExecutedIterator struct { + Event *GatewayExecuted // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -239,7 +312,7 @@ type GatewayForwardedIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayForwardedIterator) Next() bool { +func (it *GatewayExecutedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -248,7 +321,7 @@ func (it *GatewayForwardedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayForwarded) + it.Event = new(GatewayExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -263,7 +336,7 @@ func (it *GatewayForwardedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayForwarded) + it.Event = new(GatewayExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -279,53 +352,208 @@ func (it *GatewayForwardedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayForwardedIterator) Error() error { +func (it *GatewayExecutedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayForwardedIterator) Close() error { +func (it *GatewayExecutedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayForwarded represents a Forwarded event raised by the Gateway contract. -type GatewayForwarded struct { +// GatewayExecuted represents a Executed event raised by the Gateway contract. +type GatewayExecuted struct { Destination common.Address Value *big.Int Data []byte Raw types.Log // Blockchain specific contextual infos } -// FilterForwarded is a free log retrieval operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // -// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) FilterForwarded(opts *bind.FilterOpts, destination []common.Address) (*GatewayForwardedIterator, error) { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayExecutedIterator, error) { var destinationRule []interface{} for _, destinationItem := range destination { destinationRule = append(destinationRule, destinationItem) } - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Forwarded", destinationRule) + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Executed", destinationRule) if err != nil { return nil, err } - return &GatewayForwardedIterator{contract: _Gateway.contract, event: "Forwarded", logs: logs, sub: sub}, nil + return &GatewayExecutedIterator{contract: _Gateway.contract, event: "Executed", logs: logs, sub: sub}, nil } -// WatchForwarded is a free log subscription operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // -// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) WatchForwarded(opts *bind.WatchOpts, sink chan<- *GatewayForwarded, destination []common.Address) (event.Subscription, error) { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayExecuted, destination []common.Address) (event.Subscription, error) { var destinationRule []interface{} for _, destinationItem := range destination { destinationRule = append(destinationRule, destinationItem) } - logs, sub, err := _Gateway.contract.WatchLogs(opts, "Forwarded", destinationRule) + logs, sub, err := _Gateway.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayExecuted) + if err := _Gateway.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) ParseExecuted(log types.Log) (*GatewayExecuted, error) { + event := new(GatewayExecuted) + if err := _Gateway.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the Gateway contract. +type GatewayExecutedWithERC20Iterator struct { + Event *GatewayExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayExecutedWithERC20 represents a ExecutedWithERC20 event raised by the Gateway contract. +type GatewayExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayExecutedWithERC20Iterator{contract: _Gateway.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -335,8 +563,8 @@ func (_Gateway *GatewayFilterer) WatchForwarded(opts *bind.WatchOpts, sink chan< select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayForwarded) - if err := _Gateway.contract.UnpackLog(event, "Forwarded", log); err != nil { + event := new(GatewayExecutedWithERC20) + if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -357,12 +585,12 @@ func (_Gateway *GatewayFilterer) WatchForwarded(opts *bind.WatchOpts, sink chan< }), nil } -// ParseForwarded is a log parse operation binding the contract event 0xc1de93dfa06362c6a616cde73ec17d116c0d588dd1df70f27f91b500de207c41. +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// Solidity: event Forwarded(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) ParseForwarded(log types.Log) (*GatewayForwarded, error) { - event := new(GatewayForwarded) - if err := _Gateway.contract.UnpackLog(event, "Forwarded", log); err != nil { +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayExecutedWithERC20, error) { + event := new(GatewayExecutedWithERC20) + if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/receiver.sol/receiver.go b/pkg/contracts/prototypes/receiver.sol/receiver.go index 19b4531c..8e04e47c 100644 --- a/pkg/contracts/prototypes/receiver.sol/receiver.go +++ b/pkg/contracts/prototypes/receiver.sol/receiver.go @@ -31,8 +31,8 @@ var ( // ReceiverMetaData contains all meta data concerning the Receiver contract. var ReceiverMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedD\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveC\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveD\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // ReceiverABI is the input ABI used to generate the binding from. @@ -244,6 +244,48 @@ func (_Receiver *ReceiverTransactorSession) ReceiveB(strs []string, nums []*big. return _Receiver.Contract.ReceiveB(&_Receiver.TransactOpts, strs, nums, flag) } +// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// +// Solidity: function receiveC(uint256 amount, address token, address destination) returns() +func (_Receiver *ReceiverTransactor) ReceiveC(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _Receiver.contract.Transact(opts, "receiveC", amount, token, destination) +} + +// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// +// Solidity: function receiveC(uint256 amount, address token, address destination) returns() +func (_Receiver *ReceiverSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveC(&_Receiver.TransactOpts, amount, token, destination) +} + +// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// +// Solidity: function receiveC(uint256 amount, address token, address destination) returns() +func (_Receiver *ReceiverTransactorSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _Receiver.Contract.ReceiveC(&_Receiver.TransactOpts, amount, token, destination) +} + +// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// +// Solidity: function receiveD() returns() +func (_Receiver *ReceiverTransactor) ReceiveD(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Receiver.contract.Transact(opts, "receiveD") +} + +// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// +// Solidity: function receiveD() returns() +func (_Receiver *ReceiverSession) ReceiveD() (*types.Transaction, error) { + return _Receiver.Contract.ReceiveD(&_Receiver.TransactOpts) +} + +// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// +// Solidity: function receiveD() returns() +func (_Receiver *ReceiverTransactorSession) ReceiveD() (*types.Transaction, error) { + return _Receiver.Contract.ReceiveD(&_Receiver.TransactOpts) +} + // ReceiverReceivedAIterator is returned from FilterReceivedA and is used to iterate over the raw logs and unpacked data for ReceivedA events raised by the Receiver contract. type ReceiverReceivedAIterator struct { Event *ReceiverReceivedA // Event containing the contract specifics and raw log @@ -518,3 +560,274 @@ func (_Receiver *ReceiverFilterer) ParseReceivedB(log types.Log) (*ReceiverRecei event.Raw = log return event, nil } + +// ReceiverReceivedCIterator is returned from FilterReceivedC and is used to iterate over the raw logs and unpacked data for ReceivedC events raised by the Receiver contract. +type ReceiverReceivedCIterator struct { + Event *ReceiverReceivedC // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ReceiverReceivedCIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedC) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedC) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ReceiverReceivedCIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ReceiverReceivedCIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ReceiverReceivedC represents a ReceivedC event raised by the Receiver contract. +type ReceiverReceivedC struct { + Sender common.Address + Amount *big.Int + Token common.Address + Destination common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedC is a free log retrieval operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// +// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) +func (_Receiver *ReceiverFilterer) FilterReceivedC(opts *bind.FilterOpts) (*ReceiverReceivedCIterator, error) { + + logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedC") + if err != nil { + return nil, err + } + return &ReceiverReceivedCIterator{contract: _Receiver.contract, event: "ReceivedC", logs: logs, sub: sub}, nil +} + +// WatchReceivedC is a free log subscription operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// +// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) +func (_Receiver *ReceiverFilterer) WatchReceivedC(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedC) (event.Subscription, error) { + + logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedC") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ReceiverReceivedC) + if err := _Receiver.contract.UnpackLog(event, "ReceivedC", 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 +} + +// ParseReceivedC is a log parse operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// +// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) +func (_Receiver *ReceiverFilterer) ParseReceivedC(log types.Log) (*ReceiverReceivedC, error) { + event := new(ReceiverReceivedC) + if err := _Receiver.contract.UnpackLog(event, "ReceivedC", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ReceiverReceivedDIterator is returned from FilterReceivedD and is used to iterate over the raw logs and unpacked data for ReceivedD events raised by the Receiver contract. +type ReceiverReceivedDIterator struct { + Event *ReceiverReceivedD // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ReceiverReceivedDIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedD) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ReceiverReceivedD) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ReceiverReceivedDIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ReceiverReceivedDIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ReceiverReceivedD represents a ReceivedD event raised by the Receiver contract. +type ReceiverReceivedD struct { + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedD is a free log retrieval operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// +// Solidity: event ReceivedD(address sender) +func (_Receiver *ReceiverFilterer) FilterReceivedD(opts *bind.FilterOpts) (*ReceiverReceivedDIterator, error) { + + logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedD") + if err != nil { + return nil, err + } + return &ReceiverReceivedDIterator{contract: _Receiver.contract, event: "ReceivedD", logs: logs, sub: sub}, nil +} + +// WatchReceivedD is a free log subscription operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// +// Solidity: event ReceivedD(address sender) +func (_Receiver *ReceiverFilterer) WatchReceivedD(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedD) (event.Subscription, error) { + + logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedD") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ReceiverReceivedD) + if err := _Receiver.contract.UnpackLog(event, "ReceivedD", 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 +} + +// ParseReceivedD is a log parse operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// +// Solidity: event ReceivedD(address sender) +func (_Receiver *ReceiverFilterer) ParseReceivedD(log types.Log) (*ReceiverReceivedD, error) { + event := new(ReceiverReceivedD) + if err := _Receiver.contract.UnpackLog(event, "ReceivedD", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/testerc20.sol/testerc20.go b/pkg/contracts/prototypes/testerc20.sol/testerc20.go new file mode 100644 index 00000000..24a6d264 --- /dev/null +++ b/pkg/contracts/prototypes/testerc20.sol/testerc20.go @@ -0,0 +1,823 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package testerc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// TestERC20MetaData contains all meta data concerning the TestERC20 contract. +var TestERC20MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// TestERC20ABI is the input ABI used to generate the binding from. +// Deprecated: Use TestERC20MetaData.ABI instead. +var TestERC20ABI = TestERC20MetaData.ABI + +// TestERC20Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use TestERC20MetaData.Bin instead. +var TestERC20Bin = TestERC20MetaData.Bin + +// DeployTestERC20 deploys a new Ethereum contract, binding an instance of TestERC20 to it. +func DeployTestERC20(auth *bind.TransactOpts, backend bind.ContractBackend, name string, symbol string) (common.Address, *types.Transaction, *TestERC20, error) { + parsed, err := TestERC20MetaData.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(TestERC20Bin), backend, name, symbol) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &TestERC20{TestERC20Caller: TestERC20Caller{contract: contract}, TestERC20Transactor: TestERC20Transactor{contract: contract}, TestERC20Filterer: TestERC20Filterer{contract: contract}}, nil +} + +// TestERC20 is an auto generated Go binding around an Ethereum contract. +type TestERC20 struct { + TestERC20Caller // Read-only binding to the contract + TestERC20Transactor // Write-only binding to the contract + TestERC20Filterer // Log filterer for contract events +} + +// TestERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type TestERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type TestERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type TestERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type TestERC20Session struct { + Contract *TestERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type TestERC20CallerSession struct { + Contract *TestERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// TestERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type TestERC20TransactorSession struct { + Contract *TestERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type TestERC20Raw struct { + Contract *TestERC20 // Generic contract binding to access the raw methods on +} + +// TestERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type TestERC20CallerRaw struct { + Contract *TestERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// TestERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type TestERC20TransactorRaw struct { + Contract *TestERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewTestERC20 creates a new instance of TestERC20, bound to a specific deployed contract. +func NewTestERC20(address common.Address, backend bind.ContractBackend) (*TestERC20, error) { + contract, err := bindTestERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &TestERC20{TestERC20Caller: TestERC20Caller{contract: contract}, TestERC20Transactor: TestERC20Transactor{contract: contract}, TestERC20Filterer: TestERC20Filterer{contract: contract}}, nil +} + +// NewTestERC20Caller creates a new read-only instance of TestERC20, bound to a specific deployed contract. +func NewTestERC20Caller(address common.Address, caller bind.ContractCaller) (*TestERC20Caller, error) { + contract, err := bindTestERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &TestERC20Caller{contract: contract}, nil +} + +// NewTestERC20Transactor creates a new write-only instance of TestERC20, bound to a specific deployed contract. +func NewTestERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*TestERC20Transactor, error) { + contract, err := bindTestERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &TestERC20Transactor{contract: contract}, nil +} + +// NewTestERC20Filterer creates a new log filterer instance of TestERC20, bound to a specific deployed contract. +func NewTestERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*TestERC20Filterer, error) { + contract, err := bindTestERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &TestERC20Filterer{contract: contract}, nil +} + +// bindTestERC20 binds a generic wrapper to an already deployed contract. +func bindTestERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := TestERC20MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestERC20 *TestERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestERC20.Contract.TestERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestERC20 *TestERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestERC20.Contract.TestERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestERC20 *TestERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestERC20.Contract.TestERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestERC20 *TestERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestERC20 *TestERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestERC20 *TestERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestERC20.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_TestERC20 *TestERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _TestERC20.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_TestERC20 *TestERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _TestERC20.Contract.Allowance(&_TestERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_TestERC20 *TestERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _TestERC20.Contract.Allowance(&_TestERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_TestERC20 *TestERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _TestERC20.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 + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_TestERC20 *TestERC20Session) BalanceOf(account common.Address) (*big.Int, error) { + return _TestERC20.Contract.BalanceOf(&_TestERC20.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_TestERC20 *TestERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _TestERC20.Contract.BalanceOf(&_TestERC20.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_TestERC20 *TestERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _TestERC20.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_TestERC20 *TestERC20Session) Decimals() (uint8, error) { + return _TestERC20.Contract.Decimals(&_TestERC20.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_TestERC20 *TestERC20CallerSession) Decimals() (uint8, error) { + return _TestERC20.Contract.Decimals(&_TestERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TestERC20 *TestERC20Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _TestERC20.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TestERC20 *TestERC20Session) Name() (string, error) { + return _TestERC20.Contract.Name(&_TestERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TestERC20 *TestERC20CallerSession) Name() (string, error) { + return _TestERC20.Contract.Name(&_TestERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TestERC20 *TestERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _TestERC20.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TestERC20 *TestERC20Session) Symbol() (string, error) { + return _TestERC20.Contract.Symbol(&_TestERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TestERC20 *TestERC20CallerSession) Symbol() (string, error) { + return _TestERC20.Contract.Symbol(&_TestERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TestERC20 *TestERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _TestERC20.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TestERC20 *TestERC20Session) TotalSupply() (*big.Int, error) { + return _TestERC20.Contract.TotalSupply(&_TestERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TestERC20 *TestERC20CallerSession) TotalSupply() (*big.Int, error) { + return _TestERC20.Contract.TotalSupply(&_TestERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Approve(&_TestERC20.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Approve(&_TestERC20.TransactOpts, spender, amount) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_TestERC20 *TestERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_TestERC20 *TestERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.DecreaseAllowance(&_TestERC20.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_TestERC20 *TestERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.DecreaseAllowance(&_TestERC20.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_TestERC20 *TestERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_TestERC20 *TestERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.IncreaseAllowance(&_TestERC20.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_TestERC20 *TestERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.IncreaseAllowance(&_TestERC20.TransactOpts, spender, addedValue) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address to, uint256 amount) returns() +func (_TestERC20 *TestERC20Transactor) Mint(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "mint", to, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address to, uint256 amount) returns() +func (_TestERC20 *TestERC20Session) Mint(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Mint(&_TestERC20.TransactOpts, to, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x40c10f19. +// +// Solidity: function mint(address to, uint256 amount) returns() +func (_TestERC20 *TestERC20TransactorSession) Mint(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Mint(&_TestERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Transfer(&_TestERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.Transfer(&_TestERC20.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.TransferFrom(&_TestERC20.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_TestERC20 *TestERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _TestERC20.Contract.TransferFrom(&_TestERC20.TransactOpts, from, to, amount) +} + +// TestERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the TestERC20 contract. +type TestERC20ApprovalIterator struct { + Event *TestERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestERC20Approval represents a Approval event raised by the TestERC20 contract. +type TestERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TestERC20 *TestERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TestERC20ApprovalIterator, 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 := _TestERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &TestERC20ApprovalIterator{contract: _TestERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TestERC20 *TestERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TestERC20Approval, 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 := _TestERC20.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: + // New log arrived, parse the event and forward to the user + event := new(TestERC20Approval) + if err := _TestERC20.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TestERC20 *TestERC20Filterer) ParseApproval(log types.Log) (*TestERC20Approval, error) { + event := new(TestERC20Approval) + if err := _TestERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the TestERC20 contract. +type TestERC20TransferIterator struct { + Event *TestERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestERC20Transfer represents a Transfer event raised by the TestERC20 contract. +type TestERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TestERC20 *TestERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TestERC20TransferIterator, 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 := _TestERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &TestERC20TransferIterator{contract: _TestERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TestERC20 *TestERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TestERC20Transfer, 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 := _TestERC20.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: + // New log arrived, parse the event and forward to the user + event := new(TestERC20Transfer) + if err := _TestERC20.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TestERC20 *TestERC20Filterer) ParseTransfer(log types.Log) (*TestERC20Transfer, error) { + event := new(TestERC20Transfer) + if err := _TestERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 40917f2e..ace6bb30 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -3,118 +3,120 @@ import { Contract } from "ethers"; import { ethers } from "hardhat"; describe("Gateway and Receiver", function () { - let receiver: Contract; - let gateway: Contract; - let token: Contract; - let custody: Contract; - let owner: any, destination: any; - - beforeEach(async function () { - const TestERC20 = await ethers.getContractFactory("TestERC20"); - const Receiver = await ethers.getContractFactory("Receiver"); - const Gateway = await ethers.getContractFactory("Gateway"); - const Custody = await ethers.getContractFactory("ERC20CustodyNew"); - [owner, destination] = await ethers.getSigners(); - - // Deploy the contracts - token = await TestERC20.deploy("Test Token", "TTK"); - receiver = await Receiver.deploy(); - gateway = await Gateway.deploy(); - custody = await Custody.deploy(gateway.address); - - gateway.setCustody(custody.address); - - // Mint initial supply to the owner - await token.mint(owner.address, ethers.utils.parseEther("1000")); - - // Transfer some tokens to the custody contract - await token.transfer(custody.address, ethers.utils.parseEther("500")); - }); - - it("should forward call to Receiver's receiveA function", async function () { - const str = "Hello, Hardhat!"; - const num = 42; - const flag = true; - const value = ethers.utils.parseEther("1.0"); - - // Encode the function call data - const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); - - // Call execute on the Gateway contract - const tx = await gateway.execute(receiver.address, data, { value: value }); - await tx.wait(); - - // Listen for the event - await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); - }); - - it("should forward call to Receiver's receiveB function", async function () { - const strs = ["Hello", "Hardhat"]; - const nums = [1, 2, 3]; - const flag = false; - const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); - const tx = await gateway.execute(receiver.address, data); - await tx.wait(); - await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); - }); - - it("should forward call with withdrawAndCall and give allowance to destination contract", async function () { - const amount = ethers.utils.parseEther("100"); - - // Encode the function call data for receiveC - const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); - - // Withdraw and call - const tx = await custody.withdrawAndCall(token.address, receiver.address, amount, data); - await tx.wait(); - - // Verify the event was emitted - await expect(tx).to.emit(receiver, "ReceivedC").withArgs(gateway.address, amount, token.address, destination.address); - - // Verify that the tokens were transferred to the destination address - const receiverBalance = await token.balanceOf(destination.address); - expect(receiverBalance).to.equal(amount); - - // Verify that the remaining tokens were refunded to the Custody contract - const remainingBalance = await token.balanceOf(custody.address); - expect(remainingBalance).to.equal(ethers.utils.parseEther("400")); - - // Verify that the approval was reset - const allowance = await token.allowance(gateway.address, receiver.address); - expect(allowance).to.equal(0); - }); - - it("should forward call to Receiver's receiveD function", async function () { - const data = receiver.interface.encodeFunctionData("receiveD"); - - // Execute the call - const tx = await gateway.execute(receiver.address, data); - await tx.wait(); - - // Verify the event was emitted - await expect(tx).to.emit(receiver, "ReceivedD").withArgs(gateway.address) - }); - - it("should forward call to Receiver's receiveD function through withdrawAndCall and return ERC20 tokens to custody", async function () { - const amount = ethers.utils.parseEther("100"); - - // Encode the function call data for receiveD - const data = receiver.interface.encodeFunctionData("receiveD"); - - // Withdraw and call - await custody.withdrawAndCall(token.address, receiver.address, amount, data); - - // Verify the event was emitted - await expect(custody.withdrawAndCall(token.address, receiver.address, amount, data)) - .to.emit(receiver, "ReceivedD") - .withArgs(gateway.address); - - // Verify that the remaining tokens were refunded to the Custody contract - const remainingBalance = await token.balanceOf(custody.address); - expect(remainingBalance).to.equal(ethers.utils.parseEther("500")); - - // Verify that the approval was reset - const allowance = await token.allowance(gateway.address, receiver.address); - expect(allowance).to.equal(0); - }); -}); \ No newline at end of file + let receiver: Contract; + let gateway: Contract; + let token: Contract; + let custody: Contract; + let owner: any, destination: any; + + beforeEach(async function () { + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const Receiver = await ethers.getContractFactory("Receiver"); + const Gateway = await ethers.getContractFactory("Gateway"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + [owner, destination] = await ethers.getSigners(); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + receiver = await Receiver.deploy(); + gateway = await Gateway.deploy(); + custody = await Custody.deploy(gateway.address); + + gateway.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(owner.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + }); + + it("should forward call to Receiver's receiveA function", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data + const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); + + // Call execute on the Gateway contract + const tx = await gateway.execute(receiver.address, data, { value: value }); + await tx.wait(); + + // Listen for the event + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); + }); + + it("should forward call to Receiver's receiveB function", async function () { + const strs = ["Hello", "Hardhat"]; + const nums = [1, 2, 3]; + const flag = false; + const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); + const tx = await gateway.execute(receiver.address, data); + await tx.wait(); + await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); + }); + + it("should forward call with withdrawAndCall and give allowance to destination contract", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveC + const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); + + // Withdraw and call + const tx = await custody.withdrawAndCall(token.address, receiver.address, amount, data); + await tx.wait(); + + // Verify the event was emitted + await expect(tx) + .to.emit(receiver, "ReceivedC") + .withArgs(gateway.address, amount, token.address, destination.address); + + // Verify that the tokens were transferred to the destination address + const receiverBalance = await token.balanceOf(destination.address); + expect(receiverBalance).to.equal(amount); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("400")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); + + it("should forward call to Receiver's receiveD function", async function () { + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Execute the call + const tx = await gateway.execute(receiver.address, data); + await tx.wait(); + + // Verify the event was emitted + await expect(tx).to.emit(receiver, "ReceivedD").withArgs(gateway.address); + }); + + it("should forward call to Receiver's receiveD function through withdrawAndCall and return ERC20 tokens to custody", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveD + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Withdraw and call + await custody.withdrawAndCall(token.address, receiver.address, amount, data); + + // Verify the event was emitted + await expect(custody.withdrawAndCall(token.address, receiver.address, amount, data)) + .to.emit(receiver, "ReceivedD") + .withArgs(gateway.address); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("500")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); +}); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index 909a52cf..42268dc7 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -1,91 +1,95 @@ import { expect } from "chai"; import { Contract } from "ethers"; import { ethers } from "hardhat"; -import { ERC20, ERC20CustodyNew, Gateway, Receiver, TestERC20, UniswapV2Factory, UniswapV2Pair, UniswapV2Router02 } from "../../typechain-types"; import { UniswapV2Deployer } from "uniswap-v2-deploy-plugin"; +import { + ERC20, + ERC20CustodyNew, + Gateway, + Receiver, + TestERC20, + UniswapV2Factory, + UniswapV2Pair, + UniswapV2Router02, +} from "../../typechain-types"; + describe("Uniswap Integration with Gateway", function () { - let tokenA: TestERC20; - let tokenB: TestERC20; - let factory: UniswapV2Factory; - let router: UniswapV2Router02; - let pair: UniswapV2Pair; - let custody: ERC20CustodyNew; - let gateway: Gateway; - let owner, addr1, addr2; - - beforeEach(async function () { - [owner, addr1, addr2] = await ethers.getSigners(); - - // Deploy TestERC20 tokens - const TestERC20 = await ethers.getContractFactory("TestERC20"); - tokenA = await TestERC20.deploy("Token A", "TKA") as TestERC20; - tokenB = await TestERC20.deploy("Token B", "TKB") as TestERC20; - await tokenA.mint(owner.address, ethers.utils.parseEther("1000")); - await tokenB.mint(owner.address, ethers.utils.parseEther("1000")); - - - const { - factory: newFactory, - router: newRouter, - weth9: weth - } = await UniswapV2Deployer.deploy(owner) - - factory = newFactory; - router = newRouter; - - // Approve Router to move tokens - await tokenA.approve(router.address, ethers.utils.parseEther("1000")); - await tokenB.approve(router.address, ethers.utils.parseEther("1000")); - - - // Add Liquidity - await router.addLiquidity( - tokenA.address, - tokenB.address, - ethers.utils.parseEther("500"), - ethers.utils.parseEther("500"), - 0, - 0, - owner.address, - Math.floor(Date.now() / 1000) + 60 * 20 - ); - - // Deploy Gateway and Custody Contracts - const Gateway = await ethers.getContractFactory("Gateway"); - const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - gateway = await Gateway.deploy() as Gateway; - custody = await ERC20CustodyNew.deploy(gateway.address) as ERC20CustodyNew; - - // Transfer some tokens to the custody contract - await tokenA.transfer(custody.address, ethers.utils.parseEther("100")); - await tokenB.transfer(custody.address, ethers.utils.parseEther("100")); - }); - - it("should perform a token swap on Uniswap and transfer the output tokens to a destination address", async function () { - const amountIn = ethers.utils.parseEther("50"); - - const data = router.interface.encodeFunctionData("swapExactTokensForTokens", [ - amountIn, - 0, - [tokenA.address, tokenB.address], - addr2.address, - Math.floor(Date.now() / 1000) + 60 * 20 - ]); - - // Withdraw and call - await custody.withdrawAndCall(tokenA.address, router.address, amountIn, data); - - // Verify the destination address received the tokens - const destBalance = await tokenB.balanceOf(addr2.address); - expect(destBalance).to.be.gt(0); - - // Verify the remaining tokens are refunded to the Custody contract - const remainingBalance = await tokenA.balanceOf(custody.address); - expect(remainingBalance).to.equal(ethers.utils.parseEther("50")); - - // Verify the approval was reset - const allowance = await tokenA.allowance(gateway.address, router.address); - expect(allowance).to.equal(0); - }); -}); \ No newline at end of file + let tokenA: TestERC20; + let tokenB: TestERC20; + let factory: UniswapV2Factory; + let router: UniswapV2Router02; + let pair: UniswapV2Pair; + let custody: ERC20CustodyNew; + let gateway: Gateway; + let owner, addr1, addr2; + + beforeEach(async function () { + [owner, addr1, addr2] = await ethers.getSigners(); + + // Deploy TestERC20 tokens + const TestERC20 = await ethers.getContractFactory("TestERC20"); + tokenA = (await TestERC20.deploy("Token A", "TKA")) as TestERC20; + tokenB = (await TestERC20.deploy("Token B", "TKB")) as TestERC20; + await tokenA.mint(owner.address, ethers.utils.parseEther("1000")); + await tokenB.mint(owner.address, ethers.utils.parseEther("1000")); + + const { factory: newFactory, router: newRouter, weth9: weth } = await UniswapV2Deployer.deploy(owner); + + factory = newFactory; + router = newRouter; + + // Approve Router to move tokens + await tokenA.approve(router.address, ethers.utils.parseEther("1000")); + await tokenB.approve(router.address, ethers.utils.parseEther("1000")); + + // Add Liquidity + await router.addLiquidity( + tokenA.address, + tokenB.address, + ethers.utils.parseEther("500"), + ethers.utils.parseEther("500"), + 0, + 0, + owner.address, + Math.floor(Date.now() / 1000) + 60 * 20 + ); + + // Deploy Gateway and Custody Contracts + const Gateway = await ethers.getContractFactory("Gateway"); + const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); + gateway = (await Gateway.deploy()) as Gateway; + custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; + + // Transfer some tokens to the custody contract + await tokenA.transfer(custody.address, ethers.utils.parseEther("100")); + await tokenB.transfer(custody.address, ethers.utils.parseEther("100")); + }); + + it("should perform a token swap on Uniswap and transfer the output tokens to a destination address", async function () { + const amountIn = ethers.utils.parseEther("50"); + + const data = router.interface.encodeFunctionData("swapExactTokensForTokens", [ + amountIn, + 0, + [tokenA.address, tokenB.address], + addr2.address, + Math.floor(Date.now() / 1000) + 60 * 20, + ]); + + // Withdraw and call + await custody.withdrawAndCall(tokenA.address, router.address, amountIn, data); + + // Verify the destination address received the tokens + const destBalance = await tokenB.balanceOf(addr2.address); + expect(destBalance).to.be.gt(0); + + // Verify the remaining tokens are refunded to the Custody contract + const remainingBalance = await tokenA.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("50")); + + // Verify the approval was reset + const allowance = await tokenA.allowance(gateway.address, router.address); + expect(allowance).to.equal(0); + }); +}); From 704382b3d5ebd413079818f4e3b9406083a2d187 Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 17:23:52 +0200 Subject: [PATCH 15/86] use custom error --- contracts/prototypes/Gateway.sol | 8 +++++++- .../prototypes/erc20custodynew.sol/erc20custodynew.go | 2 +- pkg/contracts/prototypes/gateway.sol/gateway.go | 4 ++-- .../contracts/prototypes/ERC20CustodyNew__factory.ts | 2 +- .../factories/contracts/prototypes/Gateway__factory.ts | 7 ++++++- 5 files changed, 17 insertions(+), 6 deletions(-) diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index e6fbe0c4..4ac0b2ed 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -5,6 +5,8 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./ERC20CustodyNew.sol"; contract Gateway { + error ExecutionFailed(); + ERC20CustodyNew public custody; event Executed(address indexed destination, uint256 value, bytes data); @@ -12,7 +14,11 @@ contract Gateway { function _execute(address destination, bytes calldata data) internal returns (bytes memory) { (bool success, bytes memory result) = destination.call{value: msg.value}(data); - require(success, "Call failed"); + + if (!success) { + revert ExecutionFailed(); + } + return result; } diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index 0e921cd7..eff67387 100644 --- a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index 8615305f..84d356e3 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -31,8 +31,8 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index 09f746f5..0b696089 100644 --- a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 9c2bbad3..5ed48731 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -10,6 +10,11 @@ import type { } from "../../../contracts/prototypes/Gateway"; const _abi = [ + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, { anonymous: false, inputs: [ @@ -153,7 +158,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] From 5e4766c352b1d8e357127b45d72b27a96da9dd1d Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 17:31:13 +0200 Subject: [PATCH 16/86] add some more comment --- contracts/prototypes/ERC20CustodyNew.sol | 3 +++ contracts/prototypes/Gateway.sol | 9 ++++++++- .../prototypes/erc20custodynew.sol/erc20custodynew.go | 2 +- pkg/contracts/prototypes/gateway.sol/gateway.go | 2 +- .../contracts/prototypes/ERC20CustodyNew__factory.ts | 2 +- .../factories/contracts/prototypes/Gateway__factory.ts | 2 +- 6 files changed, 15 insertions(+), 5 deletions(-) diff --git a/contracts/prototypes/ERC20CustodyNew.sol b/contracts/prototypes/ERC20CustodyNew.sol index a88a35a7..d28d9db0 100644 --- a/contracts/prototypes/ERC20CustodyNew.sol +++ b/contracts/prototypes/ERC20CustodyNew.sol @@ -14,12 +14,15 @@ contract ERC20CustodyNew { gateway = Gateway(_gateway); } + // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call function withdraw(address token, address to, uint256 amount) external { IERC20(token).transfer(to, amount); emit Withdraw(token, to, amount); } + // WithdrawAndCall is called by TSS address, it transfers the tokens and call a contract + // For this, it passes through the Gateway contract, it transfers the tokens to the Gateway contract and then calls the contract function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external { // Transfer the tokens to the Gateway contract IERC20(token).transfer(address(gateway), amount); diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 4ac0b2ed..806131b3 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -18,10 +18,13 @@ contract Gateway { if (!success) { revert ExecutionFailed(); } - + return result; } + // Called by the TSS + // Execution without ERC20 tokens, it is payable and can be used in the case of WithdrawAndCall for Gas ZRC20 + // It can be also used for contract call without asset movement function execute(address destination, bytes calldata data) external payable returns (bytes memory) { bytes memory result = _execute(destination, data); @@ -30,6 +33,10 @@ contract Gateway { return result; } + // Called by the ERC20Custody contract + // It call a function using ERC20 transfer + // Since the goal is to allow calling contract not designed for ZetaChain specifically, it uses ERC20 allowance system + // It provides allowance to destination contract and call destination contract. In the end, it remove remaining allowance and transfer remaining tokens back to the custody contract for security purposes function executeWithERC20( address token, address to, diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index eff67387..d67f6695 100644 --- a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index 84d356e3..07b6f09f 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -32,7 +32,7 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index 0b696089..4e887da4 100644 --- a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 5ed48731..f9b206ef 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -158,7 +158,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] From ce87491250d5d26290e0df62876ea176b816d42a Mon Sep 17 00:00:00 2001 From: lumtis Date: Wed, 19 Jun 2024 17:35:55 +0200 Subject: [PATCH 17/86] a bit more comments --- contracts/prototypes/ERC20CustodyNew.sol | 3 +++ contracts/prototypes/Gateway.sol | 2 ++ .../prototypes/erc20custodynew.sol/erc20custodynew.go | 2 +- pkg/contracts/prototypes/gateway.sol/gateway.go | 2 +- .../factories/contracts/prototypes/ERC20CustodyNew__factory.ts | 2 +- .../factories/contracts/prototypes/Gateway__factory.ts | 2 +- 6 files changed, 9 insertions(+), 4 deletions(-) diff --git a/contracts/prototypes/ERC20CustodyNew.sol b/contracts/prototypes/ERC20CustodyNew.sol index d28d9db0..e2de605f 100644 --- a/contracts/prototypes/ERC20CustodyNew.sol +++ b/contracts/prototypes/ERC20CustodyNew.sol @@ -4,6 +4,9 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./Gateway.sol"; +// As the current version, ERC20CustodyNew hold the ERC20s deposited on ZetaChain +// This version include a functionality allowing to call a contract +// ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract contract ERC20CustodyNew { Gateway public gateway; diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 806131b3..1fd931d0 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -4,6 +4,8 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./ERC20CustodyNew.sol"; +// The Gateway contract is the endpoint to call smart contracts on external chains +// The contract doesn't hold any funds and should never have active allowances contract Gateway { error ExecutionFailed(); diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index d67f6695..0917f9f4 100644 --- a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x608060405234801561001057600080fd5b50604051610a66380380610a668339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b61094f806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b91906106b6565b60405180910390f35b61007e600480360381019061007991906104e7565b6100c0565b005b61009a60048036038101906100959190610494565b610297565b005b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b8473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16856040518363ffffffff1660e01b815260040161011b92919061068d565b602060405180830381600087803b15801561013557600080fd5b505af1158015610149573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061016d919061056f565b5060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b81526004016101cf95949392919061063f565b600060405180830381600087803b1580156101e957600080fd5b505af11580156101fd573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f82011682018060405250810190610226919061059c565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e858585604051610288939291906106ec565b60405180910390a35050505050565b8273ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b81526004016102d292919061068d565b602060405180830381600087803b1580156102ec57600080fd5b505af1158015610300573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610324919061056f565b508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb8360405161038291906106d1565b60405180910390a3505050565b60006103a261039d84610743565b61071e565b9050828152602081018484840111156103be576103bd6108b4565b5b6103c9848285610812565b509392505050565b6000813590506103e0816108d4565b92915050565b6000815190506103f5816108eb565b92915050565b60008083601f840112610411576104106108aa565b5b8235905067ffffffffffffffff81111561042e5761042d6108a5565b5b60208301915083600182028301111561044a576104496108af565b5b9250929050565b600082601f830112610466576104656108aa565b5b815161047684826020860161038f565b91505092915050565b60008135905061048e81610902565b92915050565b6000806000606084860312156104ad576104ac6108be565b5b60006104bb868287016103d1565b93505060206104cc868287016103d1565b92505060406104dd8682870161047f565b9150509250925092565b600080600080600060808688031215610503576105026108be565b5b6000610511888289016103d1565b9550506020610522888289016103d1565b94505060406105338882890161047f565b935050606086013567ffffffffffffffff811115610554576105536108b9565b5b610560888289016103fb565b92509250509295509295909350565b600060208284031215610585576105846108be565b5b6000610593848285016103e6565b91505092915050565b6000602082840312156105b2576105b16108be565b5b600082015167ffffffffffffffff8111156105d0576105cf6108b9565b5b6105dc84828501610451565b91505092915050565b6105ee81610785565b82525050565b60006106008385610774565b935061060d838584610803565b610616836108c3565b840190509392505050565b61062a816107cd565b82525050565b610639816107c3565b82525050565b600060808201905061065460008301886105e5565b61066160208301876105e5565b61066e6040830186610630565b81810360608301526106818184866105f4565b90509695505050505050565b60006040820190506106a260008301856105e5565b6106af6020830184610630565b9392505050565b60006020820190506106cb6000830184610621565b92915050565b60006020820190506106e66000830184610630565b92915050565b60006040820190506107016000830186610630565b81810360208301526107148184866105f4565b9050949350505050565b6000610728610739565b90506107348282610845565b919050565b6000604051905090565b600067ffffffffffffffff82111561075e5761075d610876565b5b610767826108c3565b9050602081019050919050565b600082825260208201905092915050565b6000610790826107a3565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006107d8826107df565b9050919050565b60006107ea826107f1565b9050919050565b60006107fc826107a3565b9050919050565b82818337600083830152505050565b60005b83811015610830578082015181840152602081019050610815565b8381111561083f576000848401525b50505050565b61084e826108c3565b810181811067ffffffffffffffff8211171561086d5761086c610876565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b6108dd81610785565b81146108e857600080fd5b50565b6108f481610797565b81146108ff57600080fd5b50565b61090b816107c3565b811461091657600080fd5b5056fea2646970667358221220237a91eeafaeed0a29e1d53d1226aea598d71abac48e257d39f2640690a2ef3e64736f6c63430008070033", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index 07b6f09f..ad17dbf3 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -32,7 +32,7 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index 4e887da4..a994cff3 100644 --- a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index f9b206ef..03a4c1ce 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -158,7 +158,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] From 278c327d4046b503629ce69f3f4cbb6e99272726 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 26 Jun 2024 08:26:58 +0100 Subject: [PATCH 18/86] chore: change Gateway contract to be upgradable (#175) --- contracts/prototypes/ERC20CustodyNew.sol | 6 +- contracts/prototypes/Gateway.sol | 23 +- contracts/prototypes/GatewayUpgradeTest.sol | 87 + contracts/prototypes/interfaces.sol | 13 + hardhat.config.ts | 1 + package.json | 2 + .../erc20custodynew.sol/erc20custodynew.go | 4 +- .../prototypes/gateway.sol/gateway.go | 1049 +++++++++++- .../gatewayupgradetest.go | 1475 +++++++++++++++++ .../prototypes/interfaces.sol/igateway.go | 223 +++ .../ownableupgradeable.go | 541 ++++++ .../ierc1967upgradeable.go | 604 +++++++ .../ibeaconupgradeable.go | 212 +++ .../erc1967upgradeupgradeable.go | 738 +++++++++ .../utils/initializable.sol/initializable.go | 315 ++++ .../uupsupgradeable.sol/uupsupgradeable.go | 811 +++++++++ .../addressupgradeable.go | 203 +++ .../contextupgradeable.go | 315 ++++ .../storageslotupgradeable.go | 203 +++ test/prototypes/GatewayIntegration.spec.ts | 8 +- test/prototypes/GatewayUniswap.spec.ts | 7 +- test/prototypes/GatewayUpgrade.spec.ts | 66 + .../access/OwnableUpgradeable.ts | 188 +++ .../contracts-upgradeable/access/index.ts | 4 + .../contracts-upgradeable/index.ts | 11 + .../interfaces/IERC1967Upgradeable.ts | 115 ++ .../IERC1822ProxiableUpgradeable.ts | 88 + .../draft-IERC1822Upgradeable.sol/index.ts | 4 + .../contracts-upgradeable/interfaces/index.ts | 6 + .../ERC1967/ERC1967UpgradeUpgradeable.ts | 127 ++ .../proxy/ERC1967/index.ts | 4 + .../proxy/beacon/IBeaconUpgradeable.ts | 88 + .../proxy/beacon/index.ts | 4 + .../contracts-upgradeable/proxy/index.ts | 9 + .../proxy/utils/Initializable.ts | 70 + .../proxy/utils/UUPSUpgradeable.ts | 238 +++ .../proxy/utils/index.ts | 5 + .../utils/ContextUpgradeable.ts | 70 + .../contracts-upgradeable/utils/index.ts | 4 + typechain-types/@openzeppelin/index.ts | 2 + .../contracts/prototypes/Gateway.ts | 286 ++++ .../prototypes/GatewayUpgradeTest.ts | 559 +++++++ .../prototypes/GatewayV2.sol/Gateway.ts | 559 +++++++ .../prototypes/GatewayV2.sol/GatewayV2.ts | 559 +++++++ .../prototypes/GatewayV2.sol/index.ts | 5 + .../contracts/prototypes/GatewayV2.ts | 559 +++++++ typechain-types/contracts/prototypes/index.ts | 3 + .../prototypes/interfaces.sol/IGateway.ts | 165 ++ .../prototypes/interfaces.sol/index.ts | 4 + .../access/OwnableUpgradeable__factory.ts | 91 + .../contracts-upgradeable/access/index.ts | 4 + .../contracts-upgradeable/index.ts | 7 + .../IERC1967Upgradeable__factory.ts | 71 + .../IERC1822ProxiableUpgradeable__factory.ts | 43 + .../draft-IERC1822Upgradeable.sol/index.ts | 4 + .../contracts-upgradeable/interfaces/index.ts | 5 + .../ERC1967UpgradeUpgradeable__factory.ts | 88 + .../proxy/ERC1967/index.ts | 4 + .../beacon/IBeaconUpgradeable__factory.ts | 39 + .../proxy/beacon/index.ts | 4 + .../contracts-upgradeable/proxy/index.ts | 6 + .../proxy/utils/Initializable__factory.ts | 39 + .../proxy/utils/UUPSUpgradeable__factory.ts | 128 ++ .../proxy/utils/index.ts | 5 + .../utils/ContextUpgradeable__factory.ts | 39 + .../contracts-upgradeable/utils/index.ts | 4 + .../factories/@openzeppelin/index.ts | 1 + .../prototypes/ERC20CustodyNew__factory.ts | 4 +- .../prototypes/GatewayUpgradeTest__factory.ts | 374 +++++ .../GatewayV2.sol/GatewayV2__factory.ts | 374 +++++ .../GatewayV2.sol/Gateway__factory.ts | 374 +++++ .../prototypes/GatewayV2.sol/index.ts | 5 + .../prototypes/GatewayV2__factory.ts | 374 +++++ .../contracts/prototypes/Gateway__factory.ts | 170 +- .../factories/contracts/prototypes/index.ts | 2 + .../interfaces.sol/IGateway__factory.ts | 84 + .../prototypes/interfaces.sol/index.ts | 4 + typechain-types/hardhat.d.ts | 90 + typechain-types/index.ts | 20 + yarn.lock | 679 +++++++- 80 files changed, 13666 insertions(+), 112 deletions(-) create mode 100644 contracts/prototypes/GatewayUpgradeTest.sol create mode 100644 contracts/prototypes/interfaces.sol create mode 100644 pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go create mode 100644 pkg/contracts/prototypes/interfaces.sol/igateway.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/access/ownableupgradeable.sol/ownableupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/interfaces/ierc1967upgradeable.sol/ierc1967upgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/proxy/beacon/ibeaconupgradeable.sol/ibeaconupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/proxy/erc1967/erc1967upgradeupgradeable.sol/erc1967upgradeupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/proxy/utils/initializable.sol/initializable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/proxy/utils/uupsupgradeable.sol/uupsupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/utils/addressupgradeable.sol/addressupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/utils/contextupgradeable.sol/contextupgradeable.go create mode 100644 pkg/openzeppelin/contracts-upgradeable/utils/storageslotupgradeable.sol/storageslotupgradeable.go create mode 100644 test/prototypes/GatewayUpgrade.spec.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/access/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/interfaces/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.ts create mode 100644 typechain-types/@openzeppelin/contracts-upgradeable/utils/index.ts create mode 100644 typechain-types/contracts/prototypes/GatewayUpgradeTest.ts create mode 100644 typechain-types/contracts/prototypes/GatewayV2.sol/Gateway.ts create mode 100644 typechain-types/contracts/prototypes/GatewayV2.sol/GatewayV2.ts create mode 100644 typechain-types/contracts/prototypes/GatewayV2.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/GatewayV2.ts create mode 100644 typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts create mode 100644 typechain-types/contracts/prototypes/interfaces.sol/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/access/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory.ts create mode 100644 typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayV2.sol/GatewayV2__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayV2.sol/Gateway__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayV2.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/GatewayV2__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/interfaces.sol/index.ts diff --git a/contracts/prototypes/ERC20CustodyNew.sol b/contracts/prototypes/ERC20CustodyNew.sol index e2de605f..803eec8e 100644 --- a/contracts/prototypes/ERC20CustodyNew.sol +++ b/contracts/prototypes/ERC20CustodyNew.sol @@ -2,19 +2,19 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./Gateway.sol"; +import "./interfaces.sol"; // As the current version, ERC20CustodyNew hold the ERC20s deposited on ZetaChain // This version include a functionality allowing to call a contract // ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract contract ERC20CustodyNew { - Gateway public gateway; + IGateway public gateway; event Withdraw(address indexed token, address indexed to, uint256 amount); event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data); constructor(address _gateway) { - gateway = Gateway(_gateway); + gateway = IGateway(_gateway); } // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/Gateway.sol index 1fd931d0..04d9d8fb 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/Gateway.sol @@ -2,18 +2,33 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./ERC20CustodyNew.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; +import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; + // The Gateway contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances -contract Gateway { +contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); - ERC20CustodyNew public custody; + address public custody; event Executed(address indexed destination, uint256 value, bytes data); event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); + /// @custom:oz-upgrades-unsafe-allow constructor + constructor() { + _disableInitializers(); + } + + function initialize() public initializer { + __Ownable_init(); + __UUPSUpgradeable_init(); + } + + function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} + function _execute(address destination, bytes calldata data) internal returns (bytes memory) { (bool success, bytes memory result) = destination.call{value: msg.value}(data); @@ -66,6 +81,6 @@ contract Gateway { } function setCustody(address _custody) external { - custody = ERC20CustodyNew(_custody); + custody = _custody; } } diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/GatewayUpgradeTest.sol new file mode 100644 index 00000000..0a827536 --- /dev/null +++ b/contracts/prototypes/GatewayUpgradeTest.sol @@ -0,0 +1,87 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; +import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; + + +// NOTE: Purpose of this contract is to test upgrade process, the only difference should be event names +// The Gateway contract is the endpoint to call smart contracts on external chains +// The contract doesn't hold any funds and should never have active allowances +contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { + error ExecutionFailed(); + + address public custody; + + event ExecutedV2(address indexed destination, uint256 value, bytes data); + event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data); + + /// @custom:oz-upgrades-unsafe-allow constructor + constructor() { + _disableInitializers(); + } + + function initialize() public initializer { + __Ownable_init(); + __UUPSUpgradeable_init(); + } + + function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} + + function _execute(address destination, bytes calldata data) internal returns (bytes memory) { + (bool success, bytes memory result) = destination.call{value: msg.value}(data); + + if (!success) { + revert ExecutionFailed(); + } + + return result; + } + + // Called by the TSS + // Execution without ERC20 tokens, it is payable and can be used in the case of WithdrawAndCall for Gas ZRC20 + // It can be also used for contract call without asset movement + function execute(address destination, bytes calldata data) external payable returns (bytes memory) { + bytes memory result = _execute(destination, data); + + emit ExecutedV2(destination, msg.value, data); + + return result; + } + + // Called by the ERC20Custody contract + // It call a function using ERC20 transfer + // Since the goal is to allow calling contract not designed for ZetaChain specifically, it uses ERC20 allowance system + // It provides allowance to destination contract and call destination contract. In the end, it remove remaining allowance and transfer remaining tokens back to the custody contract for security purposes + function executeWithERC20( + address token, + address to, + uint256 amount, + bytes calldata data + ) external returns (bytes memory) { + // Approve the target contract to spend the tokens + IERC20(token).approve(to, amount); + + // Execute the call on the target contract + bytes memory result = _execute(to, data); + + // Reset approval + IERC20(token).approve(to, 0); + + // Transfer any remaining tokens back to the custody contract + uint256 remainingBalance = IERC20(token).balanceOf(address(this)); + if (remainingBalance > 0) { + IERC20(token).transfer(address(custody), remainingBalance); + } + + emit ExecutedWithERC20V2(token, to, amount, data); + + return result; + } + + function setCustody(address _custody) external { + custody = _custody; + } +} diff --git a/contracts/prototypes/interfaces.sol b/contracts/prototypes/interfaces.sol new file mode 100644 index 00000000..58a474ae --- /dev/null +++ b/contracts/prototypes/interfaces.sol @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +interface IGateway { + function executeWithERC20( + address token, + address to, + uint256 amount, + bytes calldata data + ) external returns (bytes memory); + + function execute(address destination, bytes calldata data) external payable returns (bytes memory); +} \ No newline at end of file diff --git a/hardhat.config.ts b/hardhat.config.ts index 36929410..23f6d43f 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -5,6 +5,7 @@ import "tsconfig-paths/register"; import "hardhat-abi-exporter"; import "uniswap-v2-deploy-plugin"; import "./tasks/addresses"; +import "@openzeppelin/hardhat-upgrades"; import { getHardhatConfigNetworks } from "@zetachain/networks"; import * as dotenv from "dotenv"; diff --git a/package.json b/package.json index 9cfed565..71b361e3 100644 --- a/package.json +++ b/package.json @@ -11,6 +11,8 @@ "@nomiclabs/hardhat-ethers": "^2.0.5", "@nomiclabs/hardhat-waffle": "^2.0.3", "@openzeppelin/contracts": "^4.8.3", + "@openzeppelin/contracts-upgradeable": "^4.8.3", + "@openzeppelin/hardhat-upgrades": "1.28.0", "@typechain/ethers-v5": "^10.1.0", "@typechain/hardhat": "^6.1.2", "@types/chai": "^4.3.1", diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go index 0917f9f4..84fac379 100644 --- a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go @@ -31,8 +31,8 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go index ad17dbf3..e0cb7151 100644 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ b/pkg/contracts/prototypes/gateway.sol/gateway.go @@ -31,8 +31,8 @@ var ( // GatewayMetaData contains all meta data concerning the Gateway contract. var GatewayMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"contractERC20CustodyNew\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x608060405234801561001057600080fd5b50610aee806100206000396000f3fe60806040526004361061003f5760003560e01c80631cff79cd146100445780635131ab5914610074578063ae7a3a6f146100b1578063dda79b75146100da575b600080fd5b61005e600480360381019061005991906106da565b610105565b60405161006b91906108e1565b60405180910390f35b34801561008057600080fd5b5061009b60048036038101906100969190610652565b610173565b6040516100a891906108e1565b60405180910390f35b3480156100bd57600080fd5b506100d860048036038101906100d39190610625565b61045d565b005b3480156100e657600080fd5b506100ef6104a0565b6040516100fc9190610903565b60405180910390f35b606060006101148585856104c4565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f3486866040516101609392919061091e565b60405180910390a2809150509392505050565b60608573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016101b09291906108b8565b602060405180830381600087803b1580156101ca57600080fd5b505af11580156101de573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610202919061073a565b5060006102108685856104c4565b90508673ffffffffffffffffffffffffffffffffffffffff1663095ea7b38760006040518363ffffffff1660e01b815260040161024e92919061088f565b602060405180830381600087803b15801561026857600080fd5b505af115801561027c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102a0919061073a565b5060008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b81526004016102dc9190610874565b60206040518083038186803b1580156102f457600080fd5b505afa158015610308573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061032c9190610767565b905060008111156103e6578773ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b81526004016103929291906108b8565b602060405180830381600087803b1580156103ac57600080fd5b505af11580156103c0573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103e4919061073a565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b73828888886040516104479392919061091e565b60405180910390a3819250505095945050505050565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60606000808573ffffffffffffffffffffffffffffffffffffffff163486866040516104f192919061085b565b60006040518083038185875af1925050503d806000811461052e576040519150601f19603f3d011682016040523d82523d6000602084013e610533565b606091505b50915091508161056f576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60008135905061058a81610a73565b92915050565b60008151905061059f81610a8a565b92915050565b60008083601f8401126105bb576105ba610a4e565b5b8235905067ffffffffffffffff8111156105d8576105d7610a49565b5b6020830191508360018202830111156105f4576105f3610a53565b5b9250929050565b60008135905061060a81610aa1565b92915050565b60008151905061061f81610aa1565b92915050565b60006020828403121561063b5761063a610a5d565b5b60006106498482850161057b565b91505092915050565b60008060008060006080868803121561066e5761066d610a5d565b5b600061067c8882890161057b565b955050602061068d8882890161057b565b945050604061069e888289016105fb565b935050606086013567ffffffffffffffff8111156106bf576106be610a58565b5b6106cb888289016105a5565b92509250509295509295909350565b6000806000604084860312156106f3576106f2610a5d565b5b60006107018682870161057b565b935050602084013567ffffffffffffffff81111561072257610721610a58565b5b61072e868287016105a5565b92509250509250925092565b6000602082840312156107505761074f610a5d565b5b600061075e84828501610590565b91505092915050565b60006020828403121561077d5761077c610a5d565b5b600061078b84828501610610565b91505092915050565b61079d81610977565b82525050565b60006107af838561095b565b93506107bc838584610a07565b6107c583610a62565b840190509392505050565b60006107dc838561096c565b93506107e9838584610a07565b82840190509392505050565b600061080082610950565b61080a818561095b565b935061081a818560208601610a16565b61082381610a62565b840191505092915050565b610837816109bf565b82525050565b610846816109d1565b82525050565b610855816109b5565b82525050565b60006108688284866107d0565b91508190509392505050565b60006020820190506108896000830184610794565b92915050565b60006040820190506108a46000830185610794565b6108b1602083018461083d565b9392505050565b60006040820190506108cd6000830185610794565b6108da602083018461084c565b9392505050565b600060208201905081810360008301526108fb81846107f5565b905092915050565b6000602082019050610918600083018461082e565b92915050565b6000604082019050610933600083018661084c565b81810360208301526109468184866107a3565b9050949350505050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600061098282610995565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006109ca826109e3565b9050919050565b60006109dc826109b5565b9050919050565b60006109ee826109f5565b9050919050565b6000610a0082610995565b9050919050565b82818337600083830152505050565b60005b83811015610a34578082015181840152602081019050610a19565b83811115610a43576000848401525b50505050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a7c81610977565b8114610a8757600080fd5b50565b610a9381610989565b8114610a9e57600080fd5b50565b610aaa816109b5565b8114610ab557600080fd5b5056fea2646970667358221220c089eeaf89b4386d66c554855cc5118e5526411832a5f014c27c4b0daa4a560764736f6c63430008070033", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayABI is the input ABI used to generate the binding from. @@ -233,6 +233,68 @@ func (_Gateway *GatewayCallerSession) Custody() (common.Address, error) { return _Gateway.Contract.Custody(&_Gateway.CallOpts) } +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Gateway *GatewayCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Gateway.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Gateway *GatewaySession) Owner() (common.Address, error) { + return _Gateway.Contract.Owner(&_Gateway.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Gateway *GatewayCallerSession) Owner() (common.Address, error) { + return _Gateway.Contract.Owner(&_Gateway.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Gateway *GatewayCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _Gateway.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Gateway *GatewaySession) ProxiableUUID() ([32]byte, error) { + return _Gateway.Contract.ProxiableUUID(&_Gateway.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_Gateway *GatewayCallerSession) ProxiableUUID() ([32]byte, error) { + return _Gateway.Contract.ProxiableUUID(&_Gateway.CallOpts) +} + // Execute is a paid mutator transaction binding the contract method 0x1cff79cd. // // Solidity: function execute(address destination, bytes data) payable returns(bytes) @@ -275,6 +337,48 @@ func (_Gateway *GatewayTransactorSession) ExecuteWithERC20(token common.Address, return _Gateway.Contract.ExecuteWithERC20(&_Gateway.TransactOpts, token, to, amount, data) } +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Gateway *GatewayTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "initialize") +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Gateway *GatewaySession) Initialize() (*types.Transaction, error) { + return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_Gateway *GatewayTransactorSession) Initialize() (*types.Transaction, error) { + return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Gateway *GatewayTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Gateway *GatewaySession) RenounceOwnership() (*types.Transaction, error) { + return _Gateway.Contract.RenounceOwnership(&_Gateway.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Gateway *GatewayTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Gateway.Contract.RenounceOwnership(&_Gateway.TransactOpts) +} + // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. // // Solidity: function setCustody(address _custody) returns() @@ -296,9 +400,72 @@ func (_Gateway *GatewayTransactorSession) SetCustody(_custody common.Address) (* return _Gateway.Contract.SetCustody(&_Gateway.TransactOpts, _custody) } -// GatewayExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the Gateway contract. -type GatewayExecutedIterator struct { - Event *GatewayExecuted // Event containing the contract specifics and raw log +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Gateway *GatewayTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Gateway *GatewaySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Gateway.Contract.TransferOwnership(&_Gateway.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Gateway *GatewayTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Gateway.Contract.TransferOwnership(&_Gateway.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Gateway *GatewayTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Gateway *GatewaySession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _Gateway.Contract.UpgradeTo(&_Gateway.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_Gateway *GatewayTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _Gateway.Contract.UpgradeTo(&_Gateway.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Gateway *GatewayTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Gateway *GatewaySession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.UpgradeToAndCall(&_Gateway.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_Gateway *GatewayTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _Gateway.Contract.UpgradeToAndCall(&_Gateway.TransactOpts, newImplementation, data) +} + +// GatewayAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the Gateway contract. +type GatewayAdminChangedIterator struct { + Event *GatewayAdminChanged // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -312,7 +479,7 @@ type GatewayExecutedIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayExecutedIterator) Next() bool { +func (it *GatewayAdminChangedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -321,7 +488,7 @@ func (it *GatewayExecutedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayExecuted) + it.Event = new(GatewayAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -336,7 +503,7 @@ func (it *GatewayExecutedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayExecuted) + it.Event = new(GatewayAdminChanged) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -352,53 +519,42 @@ func (it *GatewayExecutedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayExecutedIterator) Error() error { +func (it *GatewayAdminChangedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayExecutedIterator) Close() error { +func (it *GatewayAdminChangedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayExecuted represents a Executed event raised by the Gateway contract. -type GatewayExecuted struct { - Destination common.Address - Value *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos +// GatewayAdminChanged represents a AdminChanged event raised by the Gateway contract. +type GatewayAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos } -// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. // -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayExecutedIterator, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Gateway *GatewayFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayAdminChangedIterator, error) { - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Executed", destinationRule) + logs, sub, err := _Gateway.contract.FilterLogs(opts, "AdminChanged") if err != nil { return nil, err } - return &GatewayExecutedIterator{contract: _Gateway.contract, event: "Executed", logs: logs, sub: sub}, nil + return &GatewayAdminChangedIterator{contract: _Gateway.contract, event: "AdminChanged", logs: logs, sub: sub}, nil } -// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. // -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayExecuted, destination []common.Address) (event.Subscription, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Gateway *GatewayFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayAdminChanged) (event.Subscription, error) { - logs, sub, err := _Gateway.contract.WatchLogs(opts, "Executed", destinationRule) + logs, sub, err := _Gateway.contract.WatchLogs(opts, "AdminChanged") if err != nil { return nil, err } @@ -408,8 +564,8 @@ func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayExecuted) - if err := _Gateway.contract.UnpackLog(event, "Executed", log); err != nil { + event := new(GatewayAdminChanged) + if err := _Gateway.contract.UnpackLog(event, "AdminChanged", log); err != nil { return err } event.Raw = log @@ -430,21 +586,21 @@ func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- }), nil } -// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. // -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) ParseExecuted(log types.Log) (*GatewayExecuted, error) { - event := new(GatewayExecuted) - if err := _Gateway.contract.UnpackLog(event, "Executed", log); err != nil { +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_Gateway *GatewayFilterer) ParseAdminChanged(log types.Log) (*GatewayAdminChanged, error) { + event := new(GatewayAdminChanged) + if err := _Gateway.contract.UnpackLog(event, "AdminChanged", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the Gateway contract. -type GatewayExecutedWithERC20Iterator struct { - Event *GatewayExecutedWithERC20 // Event containing the contract specifics and raw log +// GatewayBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the Gateway contract. +type GatewayBeaconUpgradedIterator struct { + Event *GatewayBeaconUpgraded // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -458,7 +614,7 @@ type GatewayExecutedWithERC20Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayExecutedWithERC20Iterator) Next() bool { +func (it *GatewayBeaconUpgradedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -467,7 +623,7 @@ func (it *GatewayExecutedWithERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayExecutedWithERC20) + it.Event = new(GatewayBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -482,7 +638,7 @@ func (it *GatewayExecutedWithERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayExecutedWithERC20) + it.Event = new(GatewayBeaconUpgraded) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -498,62 +654,51 @@ func (it *GatewayExecutedWithERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayExecutedWithERC20Iterator) Error() error { +func (it *GatewayBeaconUpgradedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayExecutedWithERC20Iterator) Close() error { +func (it *GatewayBeaconUpgradedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayExecutedWithERC20 represents a ExecutedWithERC20 event raised by the Gateway contract. -type GatewayExecutedWithERC20 struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte +// GatewayBeaconUpgraded represents a BeaconUpgraded event raised by the Gateway contract. +type GatewayBeaconUpgraded struct { + Beacon common.Address Raw types.Log // Blockchain specific contextual infos } -// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayExecutedWithERC20Iterator, error) { +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Gateway *GatewayFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayBeaconUpgradedIterator, error) { - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) } - logs, sub, err := _Gateway.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _Gateway.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } - return &GatewayExecutedWithERC20Iterator{contract: _Gateway.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil + return &GatewayBeaconUpgradedIterator{contract: _Gateway.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil } -// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Gateway *GatewayFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) } - logs, sub, err := _Gateway.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _Gateway.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) if err != nil { return nil, err } @@ -563,8 +708,8 @@ func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayExecutedWithERC20) - if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + event := new(GatewayBeaconUpgraded) + if err := _Gateway.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { return err } event.Raw = log @@ -585,12 +730,744 @@ func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, si }), nil } -// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayExecutedWithERC20, error) { - event := new(GatewayExecutedWithERC20) - if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_Gateway *GatewayFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayBeaconUpgraded, error) { + event := new(GatewayBeaconUpgraded) + if err := _Gateway.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the Gateway contract. +type GatewayExecutedIterator struct { + Event *GatewayExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayExecuted represents a Executed event raised by the Gateway contract. +type GatewayExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &GatewayExecutedIterator{contract: _Gateway.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayExecuted) + if err := _Gateway.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_Gateway *GatewayFilterer) ParseExecuted(log types.Log) (*GatewayExecuted, error) { + event := new(GatewayExecuted) + if err := _Gateway.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the Gateway contract. +type GatewayExecutedWithERC20Iterator struct { + Event *GatewayExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayExecutedWithERC20 represents a ExecutedWithERC20 event raised by the Gateway contract. +type GatewayExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayExecutedWithERC20Iterator{contract: _Gateway.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayExecutedWithERC20) + if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_Gateway *GatewayFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayExecutedWithERC20, error) { + event := new(GatewayExecutedWithERC20) + if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Gateway contract. +type GatewayInitializedIterator struct { + Event *GatewayInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayInitialized represents a Initialized event raised by the Gateway contract. +type GatewayInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Gateway *GatewayFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayInitializedIterator, error) { + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayInitializedIterator{contract: _Gateway.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Gateway *GatewayFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayInitialized) (event.Subscription, error) { + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayInitialized) + if err := _Gateway.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Gateway *GatewayFilterer) ParseInitialized(log types.Log) (*GatewayInitialized, error) { + event := new(GatewayInitialized) + if err := _Gateway.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Gateway contract. +type GatewayOwnershipTransferredIterator struct { + Event *GatewayOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayOwnershipTransferred represents a OwnershipTransferred event raised by the Gateway contract. +type GatewayOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Gateway *GatewayFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayOwnershipTransferredIterator, 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 := _Gateway.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayOwnershipTransferredIterator{contract: _Gateway.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Gateway *GatewayFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayOwnershipTransferred, 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 := _Gateway.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayOwnershipTransferred) + if err := _Gateway.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Gateway *GatewayFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayOwnershipTransferred, error) { + event := new(GatewayOwnershipTransferred) + if err := _Gateway.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the Gateway contract. +type GatewayUpgradedIterator struct { + Event *GatewayUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgraded represents a Upgraded event raised by the Gateway contract. +type GatewayUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Gateway *GatewayFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Gateway.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayUpgradedIterator{contract: _Gateway.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Gateway *GatewayFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _Gateway.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgraded) + if err := _Gateway.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_Gateway *GatewayFilterer) ParseUpgraded(log types.Log) (*GatewayUpgraded, error) { + event := new(GatewayUpgraded) + if err := _Gateway.contract.UnpackLog(event, "Upgraded", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go new file mode 100644 index 00000000..8a542d44 --- /dev/null +++ b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go @@ -0,0 +1,1475 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayupgradetest + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayUpgradeTestMetaData contains all meta data concerning the GatewayUpgradeTest contract. +var GatewayUpgradeTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20V2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayUpgradeTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayUpgradeTestMetaData.ABI instead. +var GatewayUpgradeTestABI = GatewayUpgradeTestMetaData.ABI + +// GatewayUpgradeTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayUpgradeTestMetaData.Bin instead. +var GatewayUpgradeTestBin = GatewayUpgradeTestMetaData.Bin + +// DeployGatewayUpgradeTest deploys a new Ethereum contract, binding an instance of GatewayUpgradeTest to it. +func DeployGatewayUpgradeTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayUpgradeTest, error) { + parsed, err := GatewayUpgradeTestMetaData.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(GatewayUpgradeTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil +} + +// GatewayUpgradeTest is an auto generated Go binding around an Ethereum contract. +type GatewayUpgradeTest struct { + GatewayUpgradeTestCaller // Read-only binding to the contract + GatewayUpgradeTestTransactor // Write-only binding to the contract + GatewayUpgradeTestFilterer // Log filterer for contract events +} + +// GatewayUpgradeTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayUpgradeTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayUpgradeTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayUpgradeTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayUpgradeTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayUpgradeTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayUpgradeTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayUpgradeTestSession struct { + Contract *GatewayUpgradeTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayUpgradeTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayUpgradeTestCallerSession struct { + Contract *GatewayUpgradeTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayUpgradeTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayUpgradeTestTransactorSession struct { + Contract *GatewayUpgradeTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayUpgradeTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayUpgradeTestRaw struct { + Contract *GatewayUpgradeTest // Generic contract binding to access the raw methods on +} + +// GatewayUpgradeTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayUpgradeTestCallerRaw struct { + Contract *GatewayUpgradeTestCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayUpgradeTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayUpgradeTestTransactorRaw struct { + Contract *GatewayUpgradeTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayUpgradeTest creates a new instance of GatewayUpgradeTest, bound to a specific deployed contract. +func NewGatewayUpgradeTest(address common.Address, backend bind.ContractBackend) (*GatewayUpgradeTest, error) { + contract, err := bindGatewayUpgradeTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil +} + +// NewGatewayUpgradeTestCaller creates a new read-only instance of GatewayUpgradeTest, bound to a specific deployed contract. +func NewGatewayUpgradeTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayUpgradeTestCaller, error) { + contract, err := bindGatewayUpgradeTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestCaller{contract: contract}, nil +} + +// NewGatewayUpgradeTestTransactor creates a new write-only instance of GatewayUpgradeTest, bound to a specific deployed contract. +func NewGatewayUpgradeTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayUpgradeTestTransactor, error) { + contract, err := bindGatewayUpgradeTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestTransactor{contract: contract}, nil +} + +// NewGatewayUpgradeTestFilterer creates a new log filterer instance of GatewayUpgradeTest, bound to a specific deployed contract. +func NewGatewayUpgradeTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayUpgradeTestFilterer, error) { + contract, err := bindGatewayUpgradeTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestFilterer{contract: contract}, nil +} + +// bindGatewayUpgradeTest binds a generic wrapper to an already deployed contract. +func bindGatewayUpgradeTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayUpgradeTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayUpgradeTest.Contract.GatewayUpgradeTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayUpgradeTest *GatewayUpgradeTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayUpgradeTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.contract.Transact(opts, method, params...) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayUpgradeTest.contract.Call(opts, &out, "custody") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Custody() (common.Address, error) { + return _GatewayUpgradeTest.Contract.Custody(&_GatewayUpgradeTest.CallOpts) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Custody() (common.Address, error) { + return _GatewayUpgradeTest.Contract.Custody(&_GatewayUpgradeTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayUpgradeTest.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Owner() (common.Address, error) { + return _GatewayUpgradeTest.Contract.Owner(&_GatewayUpgradeTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Owner() (common.Address, error) { + return _GatewayUpgradeTest.Contract.Owner(&_GatewayUpgradeTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayUpgradeTest.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) ProxiableUUID() ([32]byte, error) { + return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.ExecuteWithERC20(&_GatewayUpgradeTest.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.ExecuteWithERC20(&_GatewayUpgradeTest.TransactOpts, token, to, amount, data) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "initialize") +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Initialize() (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Initialize() (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) +} + +// GatewayUpgradeTestAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestAdminChangedIterator struct { + Event *GatewayUpgradeTestAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestAdminChanged represents a AdminChanged event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayUpgradeTestAdminChangedIterator, error) { + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayUpgradeTestAdminChangedIterator{contract: _GatewayUpgradeTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestAdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestAdminChanged) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseAdminChanged(log types.Log) (*GatewayUpgradeTestAdminChanged, error) { + event := new(GatewayUpgradeTestAdminChanged) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestBeaconUpgradedIterator struct { + Event *GatewayUpgradeTestBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayUpgradeTestBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestBeaconUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestBeaconUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayUpgradeTestBeaconUpgraded, error) { + event := new(GatewayUpgradeTestBeaconUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedV2Iterator struct { + Event *GatewayUpgradeTestExecutedV2 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestExecutedV2Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestExecutedV2Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedV2 struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayUpgradeTestExecutedV2Iterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestExecutedV2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil +} + +// WatchExecutedV2 is a free log subscription operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestExecutedV2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedV2", 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 +} + +// ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedV2(log types.Log) (*GatewayUpgradeTestExecutedV2, error) { + event := new(GatewayUpgradeTestExecutedV2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestExecutedWithERC20V2Iterator is returned from FilterExecutedWithERC20V2 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20V2 events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedWithERC20V2Iterator struct { + Event *GatewayUpgradeTestExecutedWithERC20V2 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestExecutedWithERC20V2 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20V2 is a free log retrieval operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// +// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20V2(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayUpgradeTestExecutedWithERC20V2Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestExecutedWithERC20V2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedWithERC20V2", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20V2 is a free log subscription operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// +// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20V2(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedWithERC20V2, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestExecutedWithERC20V2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20V2", 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 +} + +// ParseExecutedWithERC20V2 is a log parse operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. +// +// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedWithERC20V2(log types.Log) (*GatewayUpgradeTestExecutedWithERC20V2, error) { + event := new(GatewayUpgradeTestExecutedWithERC20V2) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestInitializedIterator struct { + Event *GatewayUpgradeTestInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestInitialized represents a Initialized event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayUpgradeTestInitializedIterator, error) { + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayUpgradeTestInitializedIterator{contract: _GatewayUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestInitialized) (event.Subscription, error) { + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestInitialized) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseInitialized(log types.Log) (*GatewayUpgradeTestInitialized, error) { + event := new(GatewayUpgradeTestInitialized) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestOwnershipTransferredIterator struct { + Event *GatewayUpgradeTestOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayUpgradeTestOwnershipTransferredIterator, 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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestOwnershipTransferredIterator{contract: _GatewayUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestOwnershipTransferred, 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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestOwnershipTransferred) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayUpgradeTestOwnershipTransferred, error) { + event := new(GatewayUpgradeTestOwnershipTransferred) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayUpgradeTestUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestUpgradedIterator struct { + Event *GatewayUpgradeTestUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayUpgradeTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayUpgradeTestUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayUpgradeTestUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayUpgradeTestUpgraded represents a Upgraded event raised by the GatewayUpgradeTest contract. +type GatewayUpgradeTestUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayUpgradeTestUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayUpgradeTestUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayUpgradeTestUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseUpgraded(log types.Log) (*GatewayUpgradeTestUpgraded, error) { + event := new(GatewayUpgradeTestUpgraded) + if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/interfaces.sol/igateway.go b/pkg/contracts/prototypes/interfaces.sol/igateway.go new file mode 100644 index 00000000..34981e17 --- /dev/null +++ b/pkg/contracts/prototypes/interfaces.sol/igateway.go @@ -0,0 +1,223 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayMetaData contains all meta data concerning the IGateway contract. +var IGatewayMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IGatewayABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayMetaData.ABI instead. +var IGatewayABI = IGatewayMetaData.ABI + +// IGateway is an auto generated Go binding around an Ethereum contract. +type IGateway struct { + IGatewayCaller // Read-only binding to the contract + IGatewayTransactor // Write-only binding to the contract + IGatewayFilterer // Log filterer for contract events +} + +// IGatewayCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewaySession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewaySession struct { + Contract *IGateway // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayCallerSession struct { + Contract *IGatewayCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayTransactorSession struct { + Contract *IGatewayTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayRaw struct { + Contract *IGateway // Generic contract binding to access the raw methods on +} + +// IGatewayCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayCallerRaw struct { + Contract *IGatewayCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayTransactorRaw struct { + Contract *IGatewayTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGateway creates a new instance of IGateway, bound to a specific deployed contract. +func NewIGateway(address common.Address, backend bind.ContractBackend) (*IGateway, error) { + contract, err := bindIGateway(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGateway{IGatewayCaller: IGatewayCaller{contract: contract}, IGatewayTransactor: IGatewayTransactor{contract: contract}, IGatewayFilterer: IGatewayFilterer{contract: contract}}, nil +} + +// NewIGatewayCaller creates a new read-only instance of IGateway, bound to a specific deployed contract. +func NewIGatewayCaller(address common.Address, caller bind.ContractCaller) (*IGatewayCaller, error) { + contract, err := bindIGateway(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayCaller{contract: contract}, nil +} + +// NewIGatewayTransactor creates a new write-only instance of IGateway, bound to a specific deployed contract. +func NewIGatewayTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayTransactor, error) { + contract, err := bindIGateway(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayTransactor{contract: contract}, nil +} + +// NewIGatewayFilterer creates a new log filterer instance of IGateway, bound to a specific deployed contract. +func NewIGatewayFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayFilterer, error) { + contract, err := bindIGateway(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayFilterer{contract: contract}, nil +} + +// bindIGateway binds a generic wrapper to an already deployed contract. +func bindIGateway(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGateway *IGatewayRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGateway.Contract.IGatewayCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGateway *IGatewayRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGateway.Contract.IGatewayTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGateway *IGatewayRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGateway.Contract.IGatewayTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGateway *IGatewayCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGateway.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGateway *IGatewayTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGateway.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGateway *IGatewayTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGateway.Contract.contract.Transact(opts, method, params...) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGateway *IGatewayTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _IGateway.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGateway *IGatewaySession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _IGateway.Contract.Execute(&_IGateway.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGateway *IGatewayTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _IGateway.Contract.Execute(&_IGateway.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGateway *IGatewayTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGateway.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGateway *IGatewaySession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGateway.Contract.ExecuteWithERC20(&_IGateway.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGateway *IGatewayTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGateway.Contract.ExecuteWithERC20(&_IGateway.TransactOpts, token, to, amount, data) +} diff --git a/pkg/openzeppelin/contracts-upgradeable/access/ownableupgradeable.sol/ownableupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/access/ownableupgradeable.sol/ownableupgradeable.go new file mode 100644 index 00000000..1aa60b6a --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/access/ownableupgradeable.sol/ownableupgradeable.go @@ -0,0 +1,541 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ownableupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// OwnableUpgradeableMetaData contains all meta data concerning the OwnableUpgradeable contract. +var OwnableUpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// OwnableUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use OwnableUpgradeableMetaData.ABI instead. +var OwnableUpgradeableABI = OwnableUpgradeableMetaData.ABI + +// OwnableUpgradeable is an auto generated Go binding around an Ethereum contract. +type OwnableUpgradeable struct { + OwnableUpgradeableCaller // Read-only binding to the contract + OwnableUpgradeableTransactor // Write-only binding to the contract + OwnableUpgradeableFilterer // Log filterer for contract events +} + +// OwnableUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type OwnableUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OwnableUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OwnableUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OwnableUpgradeableSession struct { + Contract *OwnableUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OwnableUpgradeableCallerSession struct { + Contract *OwnableUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OwnableUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OwnableUpgradeableTransactorSession struct { + Contract *OwnableUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type OwnableUpgradeableRaw struct { + Contract *OwnableUpgradeable // Generic contract binding to access the raw methods on +} + +// OwnableUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OwnableUpgradeableCallerRaw struct { + Contract *OwnableUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// OwnableUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OwnableUpgradeableTransactorRaw struct { + Contract *OwnableUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOwnableUpgradeable creates a new instance of OwnableUpgradeable, bound to a specific deployed contract. +func NewOwnableUpgradeable(address common.Address, backend bind.ContractBackend) (*OwnableUpgradeable, error) { + contract, err := bindOwnableUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &OwnableUpgradeable{OwnableUpgradeableCaller: OwnableUpgradeableCaller{contract: contract}, OwnableUpgradeableTransactor: OwnableUpgradeableTransactor{contract: contract}, OwnableUpgradeableFilterer: OwnableUpgradeableFilterer{contract: contract}}, nil +} + +// NewOwnableUpgradeableCaller creates a new read-only instance of OwnableUpgradeable, bound to a specific deployed contract. +func NewOwnableUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*OwnableUpgradeableCaller, error) { + contract, err := bindOwnableUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &OwnableUpgradeableCaller{contract: contract}, nil +} + +// NewOwnableUpgradeableTransactor creates a new write-only instance of OwnableUpgradeable, bound to a specific deployed contract. +func NewOwnableUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableUpgradeableTransactor, error) { + contract, err := bindOwnableUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &OwnableUpgradeableTransactor{contract: contract}, nil +} + +// NewOwnableUpgradeableFilterer creates a new log filterer instance of OwnableUpgradeable, bound to a specific deployed contract. +func NewOwnableUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableUpgradeableFilterer, error) { + contract, err := bindOwnableUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OwnableUpgradeableFilterer{contract: contract}, nil +} + +// bindOwnableUpgradeable binds a generic wrapper to an already deployed contract. +func bindOwnableUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := OwnableUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_OwnableUpgradeable *OwnableUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _OwnableUpgradeable.Contract.OwnableUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_OwnableUpgradeable *OwnableUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.OwnableUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_OwnableUpgradeable *OwnableUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.OwnableUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_OwnableUpgradeable *OwnableUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _OwnableUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_OwnableUpgradeable *OwnableUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_OwnableUpgradeable *OwnableUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.contract.Transact(opts, method, params...) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_OwnableUpgradeable *OwnableUpgradeableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _OwnableUpgradeable.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_OwnableUpgradeable *OwnableUpgradeableSession) Owner() (common.Address, error) { + return _OwnableUpgradeable.Contract.Owner(&_OwnableUpgradeable.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_OwnableUpgradeable *OwnableUpgradeableCallerSession) Owner() (common.Address, error) { + return _OwnableUpgradeable.Contract.Owner(&_OwnableUpgradeable.CallOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_OwnableUpgradeable *OwnableUpgradeableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _OwnableUpgradeable.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_OwnableUpgradeable *OwnableUpgradeableSession) RenounceOwnership() (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.RenounceOwnership(&_OwnableUpgradeable.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_OwnableUpgradeable *OwnableUpgradeableTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.RenounceOwnership(&_OwnableUpgradeable.TransactOpts) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_OwnableUpgradeable *OwnableUpgradeableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _OwnableUpgradeable.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_OwnableUpgradeable *OwnableUpgradeableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.TransferOwnership(&_OwnableUpgradeable.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_OwnableUpgradeable *OwnableUpgradeableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _OwnableUpgradeable.Contract.TransferOwnership(&_OwnableUpgradeable.TransactOpts, newOwner) +} + +// OwnableUpgradeableInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the OwnableUpgradeable contract. +type OwnableUpgradeableInitializedIterator struct { + Event *OwnableUpgradeableInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OwnableUpgradeableInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OwnableUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OwnableUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OwnableUpgradeableInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OwnableUpgradeableInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OwnableUpgradeableInitialized represents a Initialized event raised by the OwnableUpgradeable contract. +type OwnableUpgradeableInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) FilterInitialized(opts *bind.FilterOpts) (*OwnableUpgradeableInitializedIterator, error) { + + logs, sub, err := _OwnableUpgradeable.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &OwnableUpgradeableInitializedIterator{contract: _OwnableUpgradeable.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *OwnableUpgradeableInitialized) (event.Subscription, error) { + + logs, sub, err := _OwnableUpgradeable.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OwnableUpgradeableInitialized) + if err := _OwnableUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) ParseInitialized(log types.Log) (*OwnableUpgradeableInitialized, error) { + event := new(OwnableUpgradeableInitialized) + if err := _OwnableUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// OwnableUpgradeableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the OwnableUpgradeable contract. +type OwnableUpgradeableOwnershipTransferredIterator struct { + Event *OwnableUpgradeableOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *OwnableUpgradeableOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(OwnableUpgradeableOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(OwnableUpgradeableOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *OwnableUpgradeableOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *OwnableUpgradeableOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// OwnableUpgradeableOwnershipTransferred represents a OwnershipTransferred event raised by the OwnableUpgradeable contract. +type OwnableUpgradeableOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableUpgradeableOwnershipTransferredIterator, 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 := _OwnableUpgradeable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &OwnableUpgradeableOwnershipTransferredIterator{contract: _OwnableUpgradeable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableUpgradeableOwnershipTransferred, 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 := _OwnableUpgradeable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(OwnableUpgradeableOwnershipTransferred) + if err := _OwnableUpgradeable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_OwnableUpgradeable *OwnableUpgradeableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableUpgradeableOwnershipTransferred, error) { + event := new(OwnableUpgradeableOwnershipTransferred) + if err := _OwnableUpgradeable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/interfaces/ierc1967upgradeable.sol/ierc1967upgradeable.go b/pkg/openzeppelin/contracts-upgradeable/interfaces/ierc1967upgradeable.sol/ierc1967upgradeable.go new file mode 100644 index 00000000..59892999 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/interfaces/ierc1967upgradeable.sol/ierc1967upgradeable.go @@ -0,0 +1,604 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc1967upgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC1967UpgradeableMetaData contains all meta data concerning the IERC1967Upgradeable contract. +var IERC1967UpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"}]", +} + +// IERC1967UpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC1967UpgradeableMetaData.ABI instead. +var IERC1967UpgradeableABI = IERC1967UpgradeableMetaData.ABI + +// IERC1967Upgradeable is an auto generated Go binding around an Ethereum contract. +type IERC1967Upgradeable struct { + IERC1967UpgradeableCaller // Read-only binding to the contract + IERC1967UpgradeableTransactor // Write-only binding to the contract + IERC1967UpgradeableFilterer // Log filterer for contract events +} + +// IERC1967UpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type IERC1967UpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC1967UpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC1967UpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC1967UpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC1967UpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC1967UpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC1967UpgradeableSession struct { + Contract *IERC1967Upgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC1967UpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC1967UpgradeableCallerSession struct { + Contract *IERC1967UpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC1967UpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC1967UpgradeableTransactorSession struct { + Contract *IERC1967UpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC1967UpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type IERC1967UpgradeableRaw struct { + Contract *IERC1967Upgradeable // Generic contract binding to access the raw methods on +} + +// IERC1967UpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC1967UpgradeableCallerRaw struct { + Contract *IERC1967UpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// IERC1967UpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC1967UpgradeableTransactorRaw struct { + Contract *IERC1967UpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC1967Upgradeable creates a new instance of IERC1967Upgradeable, bound to a specific deployed contract. +func NewIERC1967Upgradeable(address common.Address, backend bind.ContractBackend) (*IERC1967Upgradeable, error) { + contract, err := bindIERC1967Upgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC1967Upgradeable{IERC1967UpgradeableCaller: IERC1967UpgradeableCaller{contract: contract}, IERC1967UpgradeableTransactor: IERC1967UpgradeableTransactor{contract: contract}, IERC1967UpgradeableFilterer: IERC1967UpgradeableFilterer{contract: contract}}, nil +} + +// NewIERC1967UpgradeableCaller creates a new read-only instance of IERC1967Upgradeable, bound to a specific deployed contract. +func NewIERC1967UpgradeableCaller(address common.Address, caller bind.ContractCaller) (*IERC1967UpgradeableCaller, error) { + contract, err := bindIERC1967Upgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC1967UpgradeableCaller{contract: contract}, nil +} + +// NewIERC1967UpgradeableTransactor creates a new write-only instance of IERC1967Upgradeable, bound to a specific deployed contract. +func NewIERC1967UpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC1967UpgradeableTransactor, error) { + contract, err := bindIERC1967Upgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC1967UpgradeableTransactor{contract: contract}, nil +} + +// NewIERC1967UpgradeableFilterer creates a new log filterer instance of IERC1967Upgradeable, bound to a specific deployed contract. +func NewIERC1967UpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC1967UpgradeableFilterer, error) { + contract, err := bindIERC1967Upgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC1967UpgradeableFilterer{contract: contract}, nil +} + +// bindIERC1967Upgradeable binds a generic wrapper to an already deployed contract. +func bindIERC1967Upgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC1967UpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC1967Upgradeable *IERC1967UpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC1967Upgradeable.Contract.IERC1967UpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC1967Upgradeable *IERC1967UpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC1967Upgradeable.Contract.IERC1967UpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC1967Upgradeable *IERC1967UpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC1967Upgradeable.Contract.IERC1967UpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC1967Upgradeable *IERC1967UpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC1967Upgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC1967Upgradeable *IERC1967UpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC1967Upgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC1967Upgradeable *IERC1967UpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC1967Upgradeable.Contract.contract.Transact(opts, method, params...) +} + +// IERC1967UpgradeableAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableAdminChangedIterator struct { + Event *IERC1967UpgradeableAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC1967UpgradeableAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC1967UpgradeableAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC1967UpgradeableAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC1967UpgradeableAdminChanged represents a AdminChanged event raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*IERC1967UpgradeableAdminChangedIterator, error) { + + logs, sub, err := _IERC1967Upgradeable.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &IERC1967UpgradeableAdminChangedIterator{contract: _IERC1967Upgradeable.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *IERC1967UpgradeableAdminChanged) (event.Subscription, error) { + + logs, sub, err := _IERC1967Upgradeable.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC1967UpgradeableAdminChanged) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) ParseAdminChanged(log types.Log) (*IERC1967UpgradeableAdminChanged, error) { + event := new(IERC1967UpgradeableAdminChanged) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC1967UpgradeableBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableBeaconUpgradedIterator struct { + Event *IERC1967UpgradeableBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC1967UpgradeableBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC1967UpgradeableBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC1967UpgradeableBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC1967UpgradeableBeaconUpgraded represents a BeaconUpgraded event raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*IERC1967UpgradeableBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _IERC1967Upgradeable.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &IERC1967UpgradeableBeaconUpgradedIterator{contract: _IERC1967Upgradeable.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *IERC1967UpgradeableBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _IERC1967Upgradeable.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC1967UpgradeableBeaconUpgraded) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) ParseBeaconUpgraded(log types.Log) (*IERC1967UpgradeableBeaconUpgraded, error) { + event := new(IERC1967UpgradeableBeaconUpgraded) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC1967UpgradeableUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableUpgradedIterator struct { + Event *IERC1967UpgradeableUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC1967UpgradeableUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC1967UpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC1967UpgradeableUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC1967UpgradeableUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC1967UpgradeableUpgraded represents a Upgraded event raised by the IERC1967Upgradeable contract. +type IERC1967UpgradeableUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*IERC1967UpgradeableUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _IERC1967Upgradeable.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &IERC1967UpgradeableUpgradedIterator{contract: _IERC1967Upgradeable.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *IERC1967UpgradeableUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _IERC1967Upgradeable.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC1967UpgradeableUpgraded) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_IERC1967Upgradeable *IERC1967UpgradeableFilterer) ParseUpgraded(log types.Log) (*IERC1967UpgradeableUpgraded, error) { + event := new(IERC1967UpgradeableUpgraded) + if err := _IERC1967Upgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/proxy/beacon/ibeaconupgradeable.sol/ibeaconupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/proxy/beacon/ibeaconupgradeable.sol/ibeaconupgradeable.go new file mode 100644 index 00000000..a4a138b4 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/proxy/beacon/ibeaconupgradeable.sol/ibeaconupgradeable.go @@ -0,0 +1,212 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ibeaconupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IBeaconUpgradeableMetaData contains all meta data concerning the IBeaconUpgradeable contract. +var IBeaconUpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// IBeaconUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use IBeaconUpgradeableMetaData.ABI instead. +var IBeaconUpgradeableABI = IBeaconUpgradeableMetaData.ABI + +// IBeaconUpgradeable is an auto generated Go binding around an Ethereum contract. +type IBeaconUpgradeable struct { + IBeaconUpgradeableCaller // Read-only binding to the contract + IBeaconUpgradeableTransactor // Write-only binding to the contract + IBeaconUpgradeableFilterer // Log filterer for contract events +} + +// IBeaconUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type IBeaconUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IBeaconUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IBeaconUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IBeaconUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IBeaconUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IBeaconUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IBeaconUpgradeableSession struct { + Contract *IBeaconUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IBeaconUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IBeaconUpgradeableCallerSession struct { + Contract *IBeaconUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IBeaconUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IBeaconUpgradeableTransactorSession struct { + Contract *IBeaconUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IBeaconUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type IBeaconUpgradeableRaw struct { + Contract *IBeaconUpgradeable // Generic contract binding to access the raw methods on +} + +// IBeaconUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IBeaconUpgradeableCallerRaw struct { + Contract *IBeaconUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// IBeaconUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IBeaconUpgradeableTransactorRaw struct { + Contract *IBeaconUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIBeaconUpgradeable creates a new instance of IBeaconUpgradeable, bound to a specific deployed contract. +func NewIBeaconUpgradeable(address common.Address, backend bind.ContractBackend) (*IBeaconUpgradeable, error) { + contract, err := bindIBeaconUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IBeaconUpgradeable{IBeaconUpgradeableCaller: IBeaconUpgradeableCaller{contract: contract}, IBeaconUpgradeableTransactor: IBeaconUpgradeableTransactor{contract: contract}, IBeaconUpgradeableFilterer: IBeaconUpgradeableFilterer{contract: contract}}, nil +} + +// NewIBeaconUpgradeableCaller creates a new read-only instance of IBeaconUpgradeable, bound to a specific deployed contract. +func NewIBeaconUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*IBeaconUpgradeableCaller, error) { + contract, err := bindIBeaconUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IBeaconUpgradeableCaller{contract: contract}, nil +} + +// NewIBeaconUpgradeableTransactor creates a new write-only instance of IBeaconUpgradeable, bound to a specific deployed contract. +func NewIBeaconUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*IBeaconUpgradeableTransactor, error) { + contract, err := bindIBeaconUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IBeaconUpgradeableTransactor{contract: contract}, nil +} + +// NewIBeaconUpgradeableFilterer creates a new log filterer instance of IBeaconUpgradeable, bound to a specific deployed contract. +func NewIBeaconUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*IBeaconUpgradeableFilterer, error) { + contract, err := bindIBeaconUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IBeaconUpgradeableFilterer{contract: contract}, nil +} + +// bindIBeaconUpgradeable binds a generic wrapper to an already deployed contract. +func bindIBeaconUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IBeaconUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IBeaconUpgradeable *IBeaconUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IBeaconUpgradeable.Contract.IBeaconUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IBeaconUpgradeable *IBeaconUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IBeaconUpgradeable.Contract.IBeaconUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IBeaconUpgradeable *IBeaconUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IBeaconUpgradeable.Contract.IBeaconUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IBeaconUpgradeable *IBeaconUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IBeaconUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IBeaconUpgradeable *IBeaconUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IBeaconUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IBeaconUpgradeable *IBeaconUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IBeaconUpgradeable.Contract.contract.Transact(opts, method, params...) +} + +// Implementation is a free data retrieval call binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() view returns(address) +func (_IBeaconUpgradeable *IBeaconUpgradeableCaller) Implementation(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _IBeaconUpgradeable.contract.Call(opts, &out, "implementation") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Implementation is a free data retrieval call binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() view returns(address) +func (_IBeaconUpgradeable *IBeaconUpgradeableSession) Implementation() (common.Address, error) { + return _IBeaconUpgradeable.Contract.Implementation(&_IBeaconUpgradeable.CallOpts) +} + +// Implementation is a free data retrieval call binding the contract method 0x5c60da1b. +// +// Solidity: function implementation() view returns(address) +func (_IBeaconUpgradeable *IBeaconUpgradeableCallerSession) Implementation() (common.Address, error) { + return _IBeaconUpgradeable.Contract.Implementation(&_IBeaconUpgradeable.CallOpts) +} diff --git a/pkg/openzeppelin/contracts-upgradeable/proxy/erc1967/erc1967upgradeupgradeable.sol/erc1967upgradeupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/proxy/erc1967/erc1967upgradeupgradeable.sol/erc1967upgradeupgradeable.go new file mode 100644 index 00000000..597aa411 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/proxy/erc1967/erc1967upgradeupgradeable.sol/erc1967upgradeupgradeable.go @@ -0,0 +1,738 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package erc1967upgradeupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ERC1967UpgradeUpgradeableMetaData contains all meta data concerning the ERC1967UpgradeUpgradeable contract. +var ERC1967UpgradeUpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"}]", +} + +// ERC1967UpgradeUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use ERC1967UpgradeUpgradeableMetaData.ABI instead. +var ERC1967UpgradeUpgradeableABI = ERC1967UpgradeUpgradeableMetaData.ABI + +// ERC1967UpgradeUpgradeable is an auto generated Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeable struct { + ERC1967UpgradeUpgradeableCaller // Read-only binding to the contract + ERC1967UpgradeUpgradeableTransactor // Write-only binding to the contract + ERC1967UpgradeUpgradeableFilterer // Log filterer for contract events +} + +// ERC1967UpgradeUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC1967UpgradeUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC1967UpgradeUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ERC1967UpgradeUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC1967UpgradeUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ERC1967UpgradeUpgradeableSession struct { + Contract *ERC1967UpgradeUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC1967UpgradeUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ERC1967UpgradeUpgradeableCallerSession struct { + Contract *ERC1967UpgradeUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ERC1967UpgradeUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ERC1967UpgradeUpgradeableTransactorSession struct { + Contract *ERC1967UpgradeUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC1967UpgradeUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeableRaw struct { + Contract *ERC1967UpgradeUpgradeable // Generic contract binding to access the raw methods on +} + +// ERC1967UpgradeUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeableCallerRaw struct { + Contract *ERC1967UpgradeUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// ERC1967UpgradeUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ERC1967UpgradeUpgradeableTransactorRaw struct { + Contract *ERC1967UpgradeUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewERC1967UpgradeUpgradeable creates a new instance of ERC1967UpgradeUpgradeable, bound to a specific deployed contract. +func NewERC1967UpgradeUpgradeable(address common.Address, backend bind.ContractBackend) (*ERC1967UpgradeUpgradeable, error) { + contract, err := bindERC1967UpgradeUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeable{ERC1967UpgradeUpgradeableCaller: ERC1967UpgradeUpgradeableCaller{contract: contract}, ERC1967UpgradeUpgradeableTransactor: ERC1967UpgradeUpgradeableTransactor{contract: contract}, ERC1967UpgradeUpgradeableFilterer: ERC1967UpgradeUpgradeableFilterer{contract: contract}}, nil +} + +// NewERC1967UpgradeUpgradeableCaller creates a new read-only instance of ERC1967UpgradeUpgradeable, bound to a specific deployed contract. +func NewERC1967UpgradeUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ERC1967UpgradeUpgradeableCaller, error) { + contract, err := bindERC1967UpgradeUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableCaller{contract: contract}, nil +} + +// NewERC1967UpgradeUpgradeableTransactor creates a new write-only instance of ERC1967UpgradeUpgradeable, bound to a specific deployed contract. +func NewERC1967UpgradeUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC1967UpgradeUpgradeableTransactor, error) { + contract, err := bindERC1967UpgradeUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableTransactor{contract: contract}, nil +} + +// NewERC1967UpgradeUpgradeableFilterer creates a new log filterer instance of ERC1967UpgradeUpgradeable, bound to a specific deployed contract. +func NewERC1967UpgradeUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC1967UpgradeUpgradeableFilterer, error) { + contract, err := bindERC1967UpgradeUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableFilterer{contract: contract}, nil +} + +// bindERC1967UpgradeUpgradeable binds a generic wrapper to an already deployed contract. +func bindERC1967UpgradeUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ERC1967UpgradeUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC1967UpgradeUpgradeable.Contract.ERC1967UpgradeUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC1967UpgradeUpgradeable.Contract.ERC1967UpgradeUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC1967UpgradeUpgradeable.Contract.ERC1967UpgradeUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC1967UpgradeUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC1967UpgradeUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC1967UpgradeUpgradeable.Contract.contract.Transact(opts, method, params...) +} + +// ERC1967UpgradeUpgradeableAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableAdminChangedIterator struct { + Event *ERC1967UpgradeUpgradeableAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC1967UpgradeUpgradeableAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC1967UpgradeUpgradeableAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC1967UpgradeUpgradeableAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC1967UpgradeUpgradeableAdminChanged represents a AdminChanged event raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*ERC1967UpgradeUpgradeableAdminChangedIterator, error) { + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableAdminChangedIterator{contract: _ERC1967UpgradeUpgradeable.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *ERC1967UpgradeUpgradeableAdminChanged) (event.Subscription, error) { + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC1967UpgradeUpgradeableAdminChanged) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) ParseAdminChanged(log types.Log) (*ERC1967UpgradeUpgradeableAdminChanged, error) { + event := new(ERC1967UpgradeUpgradeableAdminChanged) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ERC1967UpgradeUpgradeableBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableBeaconUpgradedIterator struct { + Event *ERC1967UpgradeUpgradeableBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC1967UpgradeUpgradeableBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC1967UpgradeUpgradeableBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC1967UpgradeUpgradeableBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC1967UpgradeUpgradeableBeaconUpgraded represents a BeaconUpgraded event raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*ERC1967UpgradeUpgradeableBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableBeaconUpgradedIterator{contract: _ERC1967UpgradeUpgradeable.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *ERC1967UpgradeUpgradeableBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC1967UpgradeUpgradeableBeaconUpgraded) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) ParseBeaconUpgraded(log types.Log) (*ERC1967UpgradeUpgradeableBeaconUpgraded, error) { + event := new(ERC1967UpgradeUpgradeableBeaconUpgraded) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ERC1967UpgradeUpgradeableInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableInitializedIterator struct { + Event *ERC1967UpgradeUpgradeableInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC1967UpgradeUpgradeableInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC1967UpgradeUpgradeableInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC1967UpgradeUpgradeableInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC1967UpgradeUpgradeableInitialized represents a Initialized event raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) FilterInitialized(opts *bind.FilterOpts) (*ERC1967UpgradeUpgradeableInitializedIterator, error) { + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableInitializedIterator{contract: _ERC1967UpgradeUpgradeable.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ERC1967UpgradeUpgradeableInitialized) (event.Subscription, error) { + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC1967UpgradeUpgradeableInitialized) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) ParseInitialized(log types.Log) (*ERC1967UpgradeUpgradeableInitialized, error) { + event := new(ERC1967UpgradeUpgradeableInitialized) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ERC1967UpgradeUpgradeableUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableUpgradedIterator struct { + Event *ERC1967UpgradeUpgradeableUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC1967UpgradeUpgradeableUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC1967UpgradeUpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC1967UpgradeUpgradeableUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC1967UpgradeUpgradeableUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC1967UpgradeUpgradeableUpgraded represents a Upgraded event raised by the ERC1967UpgradeUpgradeable contract. +type ERC1967UpgradeUpgradeableUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*ERC1967UpgradeUpgradeableUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &ERC1967UpgradeUpgradeableUpgradedIterator{contract: _ERC1967UpgradeUpgradeable.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *ERC1967UpgradeUpgradeableUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _ERC1967UpgradeUpgradeable.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC1967UpgradeUpgradeableUpgraded) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_ERC1967UpgradeUpgradeable *ERC1967UpgradeUpgradeableFilterer) ParseUpgraded(log types.Log) (*ERC1967UpgradeUpgradeableUpgraded, error) { + event := new(ERC1967UpgradeUpgradeableUpgraded) + if err := _ERC1967UpgradeUpgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/proxy/utils/initializable.sol/initializable.go b/pkg/openzeppelin/contracts-upgradeable/proxy/utils/initializable.sol/initializable.go new file mode 100644 index 00000000..4ac5afe3 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/proxy/utils/initializable.sol/initializable.go @@ -0,0 +1,315 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package initializable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// InitializableMetaData contains all meta data concerning the Initializable contract. +var InitializableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"}]", +} + +// InitializableABI is the input ABI used to generate the binding from. +// Deprecated: Use InitializableMetaData.ABI instead. +var InitializableABI = InitializableMetaData.ABI + +// Initializable is an auto generated Go binding around an Ethereum contract. +type Initializable struct { + InitializableCaller // Read-only binding to the contract + InitializableTransactor // Write-only binding to the contract + InitializableFilterer // Log filterer for contract events +} + +// InitializableCaller is an auto generated read-only Go binding around an Ethereum contract. +type InitializableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// InitializableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type InitializableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// InitializableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type InitializableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// InitializableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type InitializableSession struct { + Contract *Initializable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// InitializableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type InitializableCallerSession struct { + Contract *InitializableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// InitializableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type InitializableTransactorSession struct { + Contract *InitializableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// InitializableRaw is an auto generated low-level Go binding around an Ethereum contract. +type InitializableRaw struct { + Contract *Initializable // Generic contract binding to access the raw methods on +} + +// InitializableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type InitializableCallerRaw struct { + Contract *InitializableCaller // Generic read-only contract binding to access the raw methods on +} + +// InitializableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type InitializableTransactorRaw struct { + Contract *InitializableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewInitializable creates a new instance of Initializable, bound to a specific deployed contract. +func NewInitializable(address common.Address, backend bind.ContractBackend) (*Initializable, error) { + contract, err := bindInitializable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Initializable{InitializableCaller: InitializableCaller{contract: contract}, InitializableTransactor: InitializableTransactor{contract: contract}, InitializableFilterer: InitializableFilterer{contract: contract}}, nil +} + +// NewInitializableCaller creates a new read-only instance of Initializable, bound to a specific deployed contract. +func NewInitializableCaller(address common.Address, caller bind.ContractCaller) (*InitializableCaller, error) { + contract, err := bindInitializable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &InitializableCaller{contract: contract}, nil +} + +// NewInitializableTransactor creates a new write-only instance of Initializable, bound to a specific deployed contract. +func NewInitializableTransactor(address common.Address, transactor bind.ContractTransactor) (*InitializableTransactor, error) { + contract, err := bindInitializable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &InitializableTransactor{contract: contract}, nil +} + +// NewInitializableFilterer creates a new log filterer instance of Initializable, bound to a specific deployed contract. +func NewInitializableFilterer(address common.Address, filterer bind.ContractFilterer) (*InitializableFilterer, error) { + contract, err := bindInitializable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &InitializableFilterer{contract: contract}, nil +} + +// bindInitializable binds a generic wrapper to an already deployed contract. +func bindInitializable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := InitializableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Initializable *InitializableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Initializable.Contract.InitializableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Initializable *InitializableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Initializable.Contract.InitializableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Initializable *InitializableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Initializable.Contract.InitializableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Initializable *InitializableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Initializable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Initializable *InitializableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Initializable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Initializable *InitializableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Initializable.Contract.contract.Transact(opts, method, params...) +} + +// InitializableInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Initializable contract. +type InitializableInitializedIterator struct { + Event *InitializableInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *InitializableInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(InitializableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(InitializableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *InitializableInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *InitializableInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// InitializableInitialized represents a Initialized event raised by the Initializable contract. +type InitializableInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Initializable *InitializableFilterer) FilterInitialized(opts *bind.FilterOpts) (*InitializableInitializedIterator, error) { + + logs, sub, err := _Initializable.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &InitializableInitializedIterator{contract: _Initializable.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Initializable *InitializableFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *InitializableInitialized) (event.Subscription, error) { + + logs, sub, err := _Initializable.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(InitializableInitialized) + if err := _Initializable.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_Initializable *InitializableFilterer) ParseInitialized(log types.Log) (*InitializableInitialized, error) { + event := new(InitializableInitialized) + if err := _Initializable.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/proxy/utils/uupsupgradeable.sol/uupsupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/proxy/utils/uupsupgradeable.sol/uupsupgradeable.go new file mode 100644 index 00000000..f91be08a --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/proxy/utils/uupsupgradeable.sol/uupsupgradeable.go @@ -0,0 +1,811 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package uupsupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// UUPSUpgradeableMetaData contains all meta data concerning the UUPSUpgradeable contract. +var UUPSUpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// UUPSUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use UUPSUpgradeableMetaData.ABI instead. +var UUPSUpgradeableABI = UUPSUpgradeableMetaData.ABI + +// UUPSUpgradeable is an auto generated Go binding around an Ethereum contract. +type UUPSUpgradeable struct { + UUPSUpgradeableCaller // Read-only binding to the contract + UUPSUpgradeableTransactor // Write-only binding to the contract + UUPSUpgradeableFilterer // Log filterer for contract events +} + +// UUPSUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type UUPSUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UUPSUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type UUPSUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UUPSUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type UUPSUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UUPSUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type UUPSUpgradeableSession struct { + Contract *UUPSUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// UUPSUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type UUPSUpgradeableCallerSession struct { + Contract *UUPSUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// UUPSUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type UUPSUpgradeableTransactorSession struct { + Contract *UUPSUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// UUPSUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type UUPSUpgradeableRaw struct { + Contract *UUPSUpgradeable // Generic contract binding to access the raw methods on +} + +// UUPSUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type UUPSUpgradeableCallerRaw struct { + Contract *UUPSUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// UUPSUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type UUPSUpgradeableTransactorRaw struct { + Contract *UUPSUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewUUPSUpgradeable creates a new instance of UUPSUpgradeable, bound to a specific deployed contract. +func NewUUPSUpgradeable(address common.Address, backend bind.ContractBackend) (*UUPSUpgradeable, error) { + contract, err := bindUUPSUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &UUPSUpgradeable{UUPSUpgradeableCaller: UUPSUpgradeableCaller{contract: contract}, UUPSUpgradeableTransactor: UUPSUpgradeableTransactor{contract: contract}, UUPSUpgradeableFilterer: UUPSUpgradeableFilterer{contract: contract}}, nil +} + +// NewUUPSUpgradeableCaller creates a new read-only instance of UUPSUpgradeable, bound to a specific deployed contract. +func NewUUPSUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*UUPSUpgradeableCaller, error) { + contract, err := bindUUPSUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &UUPSUpgradeableCaller{contract: contract}, nil +} + +// NewUUPSUpgradeableTransactor creates a new write-only instance of UUPSUpgradeable, bound to a specific deployed contract. +func NewUUPSUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*UUPSUpgradeableTransactor, error) { + contract, err := bindUUPSUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &UUPSUpgradeableTransactor{contract: contract}, nil +} + +// NewUUPSUpgradeableFilterer creates a new log filterer instance of UUPSUpgradeable, bound to a specific deployed contract. +func NewUUPSUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*UUPSUpgradeableFilterer, error) { + contract, err := bindUUPSUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &UUPSUpgradeableFilterer{contract: contract}, nil +} + +// bindUUPSUpgradeable binds a generic wrapper to an already deployed contract. +func bindUUPSUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := UUPSUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_UUPSUpgradeable *UUPSUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _UUPSUpgradeable.Contract.UUPSUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_UUPSUpgradeable *UUPSUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UUPSUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_UUPSUpgradeable *UUPSUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UUPSUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_UUPSUpgradeable *UUPSUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _UUPSUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_UUPSUpgradeable *UUPSUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_UUPSUpgradeable *UUPSUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.contract.Transact(opts, method, params...) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_UUPSUpgradeable *UUPSUpgradeableCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _UUPSUpgradeable.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_UUPSUpgradeable *UUPSUpgradeableSession) ProxiableUUID() ([32]byte, error) { + return _UUPSUpgradeable.Contract.ProxiableUUID(&_UUPSUpgradeable.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_UUPSUpgradeable *UUPSUpgradeableCallerSession) ProxiableUUID() ([32]byte, error) { + return _UUPSUpgradeable.Contract.ProxiableUUID(&_UUPSUpgradeable.CallOpts) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_UUPSUpgradeable *UUPSUpgradeableTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _UUPSUpgradeable.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_UUPSUpgradeable *UUPSUpgradeableSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UpgradeTo(&_UUPSUpgradeable.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_UUPSUpgradeable *UUPSUpgradeableTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UpgradeTo(&_UUPSUpgradeable.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_UUPSUpgradeable *UUPSUpgradeableTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _UUPSUpgradeable.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_UUPSUpgradeable *UUPSUpgradeableSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UpgradeToAndCall(&_UUPSUpgradeable.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_UUPSUpgradeable *UUPSUpgradeableTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _UUPSUpgradeable.Contract.UpgradeToAndCall(&_UUPSUpgradeable.TransactOpts, newImplementation, data) +} + +// UUPSUpgradeableAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the UUPSUpgradeable contract. +type UUPSUpgradeableAdminChangedIterator struct { + Event *UUPSUpgradeableAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UUPSUpgradeableAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UUPSUpgradeableAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UUPSUpgradeableAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UUPSUpgradeableAdminChanged represents a AdminChanged event raised by the UUPSUpgradeable contract. +type UUPSUpgradeableAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*UUPSUpgradeableAdminChangedIterator, error) { + + logs, sub, err := _UUPSUpgradeable.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &UUPSUpgradeableAdminChangedIterator{contract: _UUPSUpgradeable.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *UUPSUpgradeableAdminChanged) (event.Subscription, error) { + + logs, sub, err := _UUPSUpgradeable.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UUPSUpgradeableAdminChanged) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) ParseAdminChanged(log types.Log) (*UUPSUpgradeableAdminChanged, error) { + event := new(UUPSUpgradeableAdminChanged) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// UUPSUpgradeableBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the UUPSUpgradeable contract. +type UUPSUpgradeableBeaconUpgradedIterator struct { + Event *UUPSUpgradeableBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UUPSUpgradeableBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UUPSUpgradeableBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UUPSUpgradeableBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UUPSUpgradeableBeaconUpgraded represents a BeaconUpgraded event raised by the UUPSUpgradeable contract. +type UUPSUpgradeableBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*UUPSUpgradeableBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _UUPSUpgradeable.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &UUPSUpgradeableBeaconUpgradedIterator{contract: _UUPSUpgradeable.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *UUPSUpgradeableBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _UUPSUpgradeable.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UUPSUpgradeableBeaconUpgraded) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) ParseBeaconUpgraded(log types.Log) (*UUPSUpgradeableBeaconUpgraded, error) { + event := new(UUPSUpgradeableBeaconUpgraded) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// UUPSUpgradeableInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the UUPSUpgradeable contract. +type UUPSUpgradeableInitializedIterator struct { + Event *UUPSUpgradeableInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UUPSUpgradeableInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UUPSUpgradeableInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UUPSUpgradeableInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UUPSUpgradeableInitialized represents a Initialized event raised by the UUPSUpgradeable contract. +type UUPSUpgradeableInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) FilterInitialized(opts *bind.FilterOpts) (*UUPSUpgradeableInitializedIterator, error) { + + logs, sub, err := _UUPSUpgradeable.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &UUPSUpgradeableInitializedIterator{contract: _UUPSUpgradeable.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *UUPSUpgradeableInitialized) (event.Subscription, error) { + + logs, sub, err := _UUPSUpgradeable.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UUPSUpgradeableInitialized) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) ParseInitialized(log types.Log) (*UUPSUpgradeableInitialized, error) { + event := new(UUPSUpgradeableInitialized) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// UUPSUpgradeableUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the UUPSUpgradeable contract. +type UUPSUpgradeableUpgradedIterator struct { + Event *UUPSUpgradeableUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UUPSUpgradeableUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UUPSUpgradeableUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UUPSUpgradeableUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UUPSUpgradeableUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UUPSUpgradeableUpgraded represents a Upgraded event raised by the UUPSUpgradeable contract. +type UUPSUpgradeableUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*UUPSUpgradeableUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _UUPSUpgradeable.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &UUPSUpgradeableUpgradedIterator{contract: _UUPSUpgradeable.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *UUPSUpgradeableUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _UUPSUpgradeable.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UUPSUpgradeableUpgraded) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_UUPSUpgradeable *UUPSUpgradeableFilterer) ParseUpgraded(log types.Log) (*UUPSUpgradeableUpgraded, error) { + event := new(UUPSUpgradeableUpgraded) + if err := _UUPSUpgradeable.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/utils/addressupgradeable.sol/addressupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/utils/addressupgradeable.sol/addressupgradeable.go new file mode 100644 index 00000000..4b250099 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/utils/addressupgradeable.sol/addressupgradeable.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package addressupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// AddressUpgradeableMetaData contains all meta data concerning the AddressUpgradeable contract. +var AddressUpgradeableMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bb9977b6b2ae9fdaa9573cc7ef606484b9a47ba5e63f00c602b173471d15b20a64736f6c63430008070033", +} + +// AddressUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use AddressUpgradeableMetaData.ABI instead. +var AddressUpgradeableABI = AddressUpgradeableMetaData.ABI + +// AddressUpgradeableBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use AddressUpgradeableMetaData.Bin instead. +var AddressUpgradeableBin = AddressUpgradeableMetaData.Bin + +// DeployAddressUpgradeable deploys a new Ethereum contract, binding an instance of AddressUpgradeable to it. +func DeployAddressUpgradeable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AddressUpgradeable, error) { + parsed, err := AddressUpgradeableMetaData.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(AddressUpgradeableBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &AddressUpgradeable{AddressUpgradeableCaller: AddressUpgradeableCaller{contract: contract}, AddressUpgradeableTransactor: AddressUpgradeableTransactor{contract: contract}, AddressUpgradeableFilterer: AddressUpgradeableFilterer{contract: contract}}, nil +} + +// AddressUpgradeable is an auto generated Go binding around an Ethereum contract. +type AddressUpgradeable struct { + AddressUpgradeableCaller // Read-only binding to the contract + AddressUpgradeableTransactor // Write-only binding to the contract + AddressUpgradeableFilterer // Log filterer for contract events +} + +// AddressUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type AddressUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AddressUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type AddressUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AddressUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type AddressUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AddressUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type AddressUpgradeableSession struct { + Contract *AddressUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// AddressUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type AddressUpgradeableCallerSession struct { + Contract *AddressUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// AddressUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type AddressUpgradeableTransactorSession struct { + Contract *AddressUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// AddressUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type AddressUpgradeableRaw struct { + Contract *AddressUpgradeable // Generic contract binding to access the raw methods on +} + +// AddressUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type AddressUpgradeableCallerRaw struct { + Contract *AddressUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// AddressUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type AddressUpgradeableTransactorRaw struct { + Contract *AddressUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewAddressUpgradeable creates a new instance of AddressUpgradeable, bound to a specific deployed contract. +func NewAddressUpgradeable(address common.Address, backend bind.ContractBackend) (*AddressUpgradeable, error) { + contract, err := bindAddressUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &AddressUpgradeable{AddressUpgradeableCaller: AddressUpgradeableCaller{contract: contract}, AddressUpgradeableTransactor: AddressUpgradeableTransactor{contract: contract}, AddressUpgradeableFilterer: AddressUpgradeableFilterer{contract: contract}}, nil +} + +// NewAddressUpgradeableCaller creates a new read-only instance of AddressUpgradeable, bound to a specific deployed contract. +func NewAddressUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*AddressUpgradeableCaller, error) { + contract, err := bindAddressUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &AddressUpgradeableCaller{contract: contract}, nil +} + +// NewAddressUpgradeableTransactor creates a new write-only instance of AddressUpgradeable, bound to a specific deployed contract. +func NewAddressUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressUpgradeableTransactor, error) { + contract, err := bindAddressUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &AddressUpgradeableTransactor{contract: contract}, nil +} + +// NewAddressUpgradeableFilterer creates a new log filterer instance of AddressUpgradeable, bound to a specific deployed contract. +func NewAddressUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressUpgradeableFilterer, error) { + contract, err := bindAddressUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &AddressUpgradeableFilterer{contract: contract}, nil +} + +// bindAddressUpgradeable binds a generic wrapper to an already deployed contract. +func bindAddressUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := AddressUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_AddressUpgradeable *AddressUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _AddressUpgradeable.Contract.AddressUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_AddressUpgradeable *AddressUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _AddressUpgradeable.Contract.AddressUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_AddressUpgradeable *AddressUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _AddressUpgradeable.Contract.AddressUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_AddressUpgradeable *AddressUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _AddressUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_AddressUpgradeable *AddressUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _AddressUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_AddressUpgradeable *AddressUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _AddressUpgradeable.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/openzeppelin/contracts-upgradeable/utils/contextupgradeable.sol/contextupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/utils/contextupgradeable.sol/contextupgradeable.go new file mode 100644 index 00000000..bcd2aa90 --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/utils/contextupgradeable.sol/contextupgradeable.go @@ -0,0 +1,315 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package contextupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ContextUpgradeableMetaData contains all meta data concerning the ContextUpgradeable contract. +var ContextUpgradeableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"}]", +} + +// ContextUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use ContextUpgradeableMetaData.ABI instead. +var ContextUpgradeableABI = ContextUpgradeableMetaData.ABI + +// ContextUpgradeable is an auto generated Go binding around an Ethereum contract. +type ContextUpgradeable struct { + ContextUpgradeableCaller // Read-only binding to the contract + ContextUpgradeableTransactor // Write-only binding to the contract + ContextUpgradeableFilterer // Log filterer for contract events +} + +// ContextUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type ContextUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContextUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ContextUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContextUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ContextUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ContextUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ContextUpgradeableSession struct { + Contract *ContextUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContextUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ContextUpgradeableCallerSession struct { + Contract *ContextUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ContextUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ContextUpgradeableTransactorSession struct { + Contract *ContextUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ContextUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type ContextUpgradeableRaw struct { + Contract *ContextUpgradeable // Generic contract binding to access the raw methods on +} + +// ContextUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ContextUpgradeableCallerRaw struct { + Contract *ContextUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// ContextUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ContextUpgradeableTransactorRaw struct { + Contract *ContextUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewContextUpgradeable creates a new instance of ContextUpgradeable, bound to a specific deployed contract. +func NewContextUpgradeable(address common.Address, backend bind.ContractBackend) (*ContextUpgradeable, error) { + contract, err := bindContextUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ContextUpgradeable{ContextUpgradeableCaller: ContextUpgradeableCaller{contract: contract}, ContextUpgradeableTransactor: ContextUpgradeableTransactor{contract: contract}, ContextUpgradeableFilterer: ContextUpgradeableFilterer{contract: contract}}, nil +} + +// NewContextUpgradeableCaller creates a new read-only instance of ContextUpgradeable, bound to a specific deployed contract. +func NewContextUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ContextUpgradeableCaller, error) { + contract, err := bindContextUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ContextUpgradeableCaller{contract: contract}, nil +} + +// NewContextUpgradeableTransactor creates a new write-only instance of ContextUpgradeable, bound to a specific deployed contract. +func NewContextUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextUpgradeableTransactor, error) { + contract, err := bindContextUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ContextUpgradeableTransactor{contract: contract}, nil +} + +// NewContextUpgradeableFilterer creates a new log filterer instance of ContextUpgradeable, bound to a specific deployed contract. +func NewContextUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextUpgradeableFilterer, error) { + contract, err := bindContextUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ContextUpgradeableFilterer{contract: contract}, nil +} + +// bindContextUpgradeable binds a generic wrapper to an already deployed contract. +func bindContextUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ContextUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContextUpgradeable *ContextUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContextUpgradeable.Contract.ContextUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContextUpgradeable *ContextUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContextUpgradeable.Contract.ContextUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContextUpgradeable *ContextUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContextUpgradeable.Contract.ContextUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ContextUpgradeable *ContextUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ContextUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ContextUpgradeable *ContextUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ContextUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ContextUpgradeable *ContextUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ContextUpgradeable.Contract.contract.Transact(opts, method, params...) +} + +// ContextUpgradeableInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ContextUpgradeable contract. +type ContextUpgradeableInitializedIterator struct { + Event *ContextUpgradeableInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ContextUpgradeableInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ContextUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ContextUpgradeableInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ContextUpgradeableInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ContextUpgradeableInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ContextUpgradeableInitialized represents a Initialized event raised by the ContextUpgradeable contract. +type ContextUpgradeableInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ContextUpgradeable *ContextUpgradeableFilterer) FilterInitialized(opts *bind.FilterOpts) (*ContextUpgradeableInitializedIterator, error) { + + logs, sub, err := _ContextUpgradeable.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &ContextUpgradeableInitializedIterator{contract: _ContextUpgradeable.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ContextUpgradeable *ContextUpgradeableFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ContextUpgradeableInitialized) (event.Subscription, error) { + + logs, sub, err := _ContextUpgradeable.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ContextUpgradeableInitialized) + if err := _ContextUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ContextUpgradeable *ContextUpgradeableFilterer) ParseInitialized(log types.Log) (*ContextUpgradeableInitialized, error) { + event := new(ContextUpgradeableInitialized) + if err := _ContextUpgradeable.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/openzeppelin/contracts-upgradeable/utils/storageslotupgradeable.sol/storageslotupgradeable.go b/pkg/openzeppelin/contracts-upgradeable/utils/storageslotupgradeable.sol/storageslotupgradeable.go new file mode 100644 index 00000000..5e1b607e --- /dev/null +++ b/pkg/openzeppelin/contracts-upgradeable/utils/storageslotupgradeable.sol/storageslotupgradeable.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package storageslotupgradeable + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StorageSlotUpgradeableMetaData contains all meta data concerning the StorageSlotUpgradeable contract. +var StorageSlotUpgradeableMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e18234fba4711fe8a78c85843309b44a2dc320c8280807033ee03f351f0af3ae64736f6c63430008070033", +} + +// StorageSlotUpgradeableABI is the input ABI used to generate the binding from. +// Deprecated: Use StorageSlotUpgradeableMetaData.ABI instead. +var StorageSlotUpgradeableABI = StorageSlotUpgradeableMetaData.ABI + +// StorageSlotUpgradeableBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StorageSlotUpgradeableMetaData.Bin instead. +var StorageSlotUpgradeableBin = StorageSlotUpgradeableMetaData.Bin + +// DeployStorageSlotUpgradeable deploys a new Ethereum contract, binding an instance of StorageSlotUpgradeable to it. +func DeployStorageSlotUpgradeable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StorageSlotUpgradeable, error) { + parsed, err := StorageSlotUpgradeableMetaData.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(StorageSlotUpgradeableBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StorageSlotUpgradeable{StorageSlotUpgradeableCaller: StorageSlotUpgradeableCaller{contract: contract}, StorageSlotUpgradeableTransactor: StorageSlotUpgradeableTransactor{contract: contract}, StorageSlotUpgradeableFilterer: StorageSlotUpgradeableFilterer{contract: contract}}, nil +} + +// StorageSlotUpgradeable is an auto generated Go binding around an Ethereum contract. +type StorageSlotUpgradeable struct { + StorageSlotUpgradeableCaller // Read-only binding to the contract + StorageSlotUpgradeableTransactor // Write-only binding to the contract + StorageSlotUpgradeableFilterer // Log filterer for contract events +} + +// StorageSlotUpgradeableCaller is an auto generated read-only Go binding around an Ethereum contract. +type StorageSlotUpgradeableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StorageSlotUpgradeableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StorageSlotUpgradeableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StorageSlotUpgradeableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StorageSlotUpgradeableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StorageSlotUpgradeableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StorageSlotUpgradeableSession struct { + Contract *StorageSlotUpgradeable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StorageSlotUpgradeableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StorageSlotUpgradeableCallerSession struct { + Contract *StorageSlotUpgradeableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StorageSlotUpgradeableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StorageSlotUpgradeableTransactorSession struct { + Contract *StorageSlotUpgradeableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StorageSlotUpgradeableRaw is an auto generated low-level Go binding around an Ethereum contract. +type StorageSlotUpgradeableRaw struct { + Contract *StorageSlotUpgradeable // Generic contract binding to access the raw methods on +} + +// StorageSlotUpgradeableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StorageSlotUpgradeableCallerRaw struct { + Contract *StorageSlotUpgradeableCaller // Generic read-only contract binding to access the raw methods on +} + +// StorageSlotUpgradeableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StorageSlotUpgradeableTransactorRaw struct { + Contract *StorageSlotUpgradeableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStorageSlotUpgradeable creates a new instance of StorageSlotUpgradeable, bound to a specific deployed contract. +func NewStorageSlotUpgradeable(address common.Address, backend bind.ContractBackend) (*StorageSlotUpgradeable, error) { + contract, err := bindStorageSlotUpgradeable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StorageSlotUpgradeable{StorageSlotUpgradeableCaller: StorageSlotUpgradeableCaller{contract: contract}, StorageSlotUpgradeableTransactor: StorageSlotUpgradeableTransactor{contract: contract}, StorageSlotUpgradeableFilterer: StorageSlotUpgradeableFilterer{contract: contract}}, nil +} + +// NewStorageSlotUpgradeableCaller creates a new read-only instance of StorageSlotUpgradeable, bound to a specific deployed contract. +func NewStorageSlotUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*StorageSlotUpgradeableCaller, error) { + contract, err := bindStorageSlotUpgradeable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StorageSlotUpgradeableCaller{contract: contract}, nil +} + +// NewStorageSlotUpgradeableTransactor creates a new write-only instance of StorageSlotUpgradeable, bound to a specific deployed contract. +func NewStorageSlotUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*StorageSlotUpgradeableTransactor, error) { + contract, err := bindStorageSlotUpgradeable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StorageSlotUpgradeableTransactor{contract: contract}, nil +} + +// NewStorageSlotUpgradeableFilterer creates a new log filterer instance of StorageSlotUpgradeable, bound to a specific deployed contract. +func NewStorageSlotUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*StorageSlotUpgradeableFilterer, error) { + contract, err := bindStorageSlotUpgradeable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StorageSlotUpgradeableFilterer{contract: contract}, nil +} + +// bindStorageSlotUpgradeable binds a generic wrapper to an already deployed contract. +func bindStorageSlotUpgradeable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StorageSlotUpgradeableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StorageSlotUpgradeable.Contract.StorageSlotUpgradeableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StorageSlotUpgradeable.Contract.StorageSlotUpgradeableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StorageSlotUpgradeable.Contract.StorageSlotUpgradeableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StorageSlotUpgradeable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StorageSlotUpgradeable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StorageSlotUpgradeable *StorageSlotUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StorageSlotUpgradeable.Contract.contract.Transact(opts, method, params...) +} diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index ace6bb30..cb6c7bc1 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -1,6 +1,6 @@ import { expect } from "chai"; import { Contract } from "ethers"; -import { ethers } from "hardhat"; +import { ethers, upgrades } from "hardhat"; describe("Gateway and Receiver", function () { let receiver: Contract; @@ -19,7 +19,10 @@ describe("Gateway and Receiver", function () { // Deploy the contracts token = await TestERC20.deploy("Test Token", "TTK"); receiver = await Receiver.deploy(); - gateway = await Gateway.deploy(); + gateway = await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + }); custody = await Custody.deploy(gateway.address); gateway.setCustody(custody.address); @@ -45,6 +48,7 @@ describe("Gateway and Receiver", function () { await tx.wait(); // Listen for the event + await expect(tx).to.emit(gateway, "Executed").withArgs(receiver.address, value, data); await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); }); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayUniswap.spec.ts index 42268dc7..7ee89a0c 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayUniswap.spec.ts @@ -1,6 +1,6 @@ import { expect } from "chai"; import { Contract } from "ethers"; -import { ethers } from "hardhat"; +import { ethers, upgrades } from "hardhat"; import { UniswapV2Deployer } from "uniswap-v2-deploy-plugin"; import { @@ -58,7 +58,10 @@ describe("Uniswap Integration with Gateway", function () { // Deploy Gateway and Custody Contracts const Gateway = await ethers.getContractFactory("Gateway"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - gateway = (await Gateway.deploy()) as Gateway; + gateway = (await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + })) as Gateway; custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; // Transfer some tokens to the custody contract diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayUpgrade.spec.ts new file mode 100644 index 00000000..5e25924b --- /dev/null +++ b/test/prototypes/GatewayUpgrade.spec.ts @@ -0,0 +1,66 @@ +import { expect } from "chai"; +import { Contract } from "ethers"; +import { ethers, upgrades } from "hardhat"; + +describe("Gateway upgrade", function () { + let receiver: Contract; + let gateway: Contract; + let token: Contract; + let custody: Contract; + let owner: any, destination: any, randomSigner: any; + + beforeEach(async function () { + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const Receiver = await ethers.getContractFactory("Receiver"); + const Gateway = await ethers.getContractFactory("Gateway"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + [owner, destination, randomSigner] = await ethers.getSigners(); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + receiver = await Receiver.deploy(); + gateway = await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + }); + custody = await Custody.deploy(gateway.address); + + gateway.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(owner.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + }); + + it("should upgrade and forward call to Receiver's receiveA function", async function () { + // Upgrade Gateway contract + // Fail to upgrade if not using owner account + let GatewayUpgradeTest = await ethers.getContractFactory("GatewayUpgradeTest", randomSigner); + await expect(upgrades.upgradeProxy(gateway.address, GatewayUpgradeTest)).to.be.revertedWith( + "Ownable: caller is not the owner" + ); + + // Upgrade with owner account + GatewayUpgradeTest = await ethers.getContractFactory("GatewayUpgradeTest", owner); + const gatewayUpgradeTest = await upgrades.upgradeProxy(gateway.address, GatewayUpgradeTest); + + // Forward call + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data + const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); + + // Call execute on the GatewayV2 contract + const tx = await gatewayUpgradeTest.execute(receiver.address, data, { value: value }); + await tx.wait(); + + // Listen for the event + await expect(tx).to.emit(gatewayUpgradeTest, "ExecutedV2").withArgs(receiver.address, value, data); + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gatewayUpgradeTest.address, value, str, num, flag); + }); +}); diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.ts new file mode 100644 index 00000000..4ebb8a9b --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.ts @@ -0,0 +1,188 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface OwnableUpgradeableInterface extends utils.Interface { + functions: { + "owner()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "owner" | "renounceOwnership" | "transferOwnership" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + + events: { + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; +} + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface OwnableUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: OwnableUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + owner(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + owner(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + owner(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + }; + + estimateGas: { + owner(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + owner(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/access/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/access/index.ts new file mode 100644 index 00000000..5b7d8440 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/access/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { OwnableUpgradeable } from "./OwnableUpgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/index.ts new file mode 100644 index 00000000..14e80f09 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/index.ts @@ -0,0 +1,11 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as access from "./access"; +export type { access }; +import type * as interfaces from "./interfaces"; +export type { interfaces }; +import type * as proxy from "./proxy"; +export type { proxy }; +import type * as utils from "./utils"; +export type { utils }; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable.ts new file mode 100644 index 00000000..dea1e073 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable.ts @@ -0,0 +1,115 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IERC1967UpgradeableInterface extends utils.Interface { + functions: {}; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface IERC1967Upgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC1967UpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable.ts new file mode 100644 index 00000000..12802780 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable.ts @@ -0,0 +1,88 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IERC1822ProxiableUpgradeableInterface extends utils.Interface { + functions: { + "proxiableUUID()": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "proxiableUUID"): FunctionFragment; + + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IERC1822ProxiableUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC1822ProxiableUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + }; + + proxiableUUID(overrides?: CallOverrides): Promise; + + callStatic: { + proxiableUUID(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + proxiableUUID(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + proxiableUUID(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts new file mode 100644 index 00000000..694b98f2 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IERC1822ProxiableUpgradeable } from "./IERC1822ProxiableUpgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/index.ts new file mode 100644 index 00000000..794471a3 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/interfaces/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as draftIerc1822UpgradeableSol from "./draft-IERC1822Upgradeable.sol"; +export type { draftIerc1822UpgradeableSol }; +export type { IERC1967Upgradeable } from "./IERC1967Upgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.ts new file mode 100644 index 00000000..8c87141f --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.ts @@ -0,0 +1,127 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface ERC1967UpgradeUpgradeableInterface extends utils.Interface { + functions: {}; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Initialized(uint8)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface ERC1967UpgradeUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ERC1967UpgradeUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts new file mode 100644 index 00000000..3c90548c --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { ERC1967UpgradeUpgradeable } from "./ERC1967UpgradeUpgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.ts new file mode 100644 index 00000000..b8c9d2e4 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.ts @@ -0,0 +1,88 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IBeaconUpgradeableInterface extends utils.Interface { + functions: { + "implementation()": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "implementation"): FunctionFragment; + + encodeFunctionData( + functionFragment: "implementation", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "implementation", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IBeaconUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IBeaconUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + implementation(overrides?: CallOverrides): Promise<[string]>; + }; + + implementation(overrides?: CallOverrides): Promise; + + callStatic: { + implementation(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + implementation(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + implementation(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts new file mode 100644 index 00000000..51fb2a5e --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IBeaconUpgradeable } from "./IBeaconUpgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/index.ts new file mode 100644 index 00000000..c2433d8f --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/index.ts @@ -0,0 +1,9 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as erc1967 from "./ERC1967"; +export type { erc1967 }; +import type * as beacon from "./beacon"; +export type { beacon }; +import type * as utils from "./utils"; +export type { utils }; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.ts new file mode 100644 index 00000000..a97ca26e --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.ts @@ -0,0 +1,70 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface InitializableInterface extends utils.Interface { + functions: {}; + + events: { + "Initialized(uint8)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; +} + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface Initializable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: InitializableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.ts new file mode 100644 index 00000000..352a25fa --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.ts @@ -0,0 +1,238 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface UUPSUpgradeableInterface extends utils.Interface { + functions: { + "proxiableUUID()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "proxiableUUID" | "upgradeTo" | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Initialized(uint8)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface UUPSUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: UUPSUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + proxiableUUID(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + proxiableUUID(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + proxiableUUID(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + proxiableUUID(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts new file mode 100644 index 00000000..f23837ba --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { Initializable } from "./Initializable"; +export type { UUPSUpgradeable } from "./UUPSUpgradeable"; diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.ts b/typechain-types/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.ts new file mode 100644 index 00000000..6886700d --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.ts @@ -0,0 +1,70 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ContextUpgradeableInterface extends utils.Interface { + functions: {}; + + events: { + "Initialized(uint8)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; +} + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface ContextUpgradeable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ContextUpgradeableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/@openzeppelin/contracts-upgradeable/utils/index.ts b/typechain-types/@openzeppelin/contracts-upgradeable/utils/index.ts new file mode 100644 index 00000000..749da396 --- /dev/null +++ b/typechain-types/@openzeppelin/contracts-upgradeable/utils/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { ContextUpgradeable } from "./ContextUpgradeable"; diff --git a/typechain-types/@openzeppelin/index.ts b/typechain-types/@openzeppelin/index.ts index a11e4ca2..f34b8770 100644 --- a/typechain-types/@openzeppelin/index.ts +++ b/typechain-types/@openzeppelin/index.ts @@ -3,3 +3,5 @@ /* eslint-disable */ import type * as contracts from "./contracts"; export type { contracts }; +import type * as contractsUpgradeable from "./contracts-upgradeable"; +export type { contractsUpgradeable }; diff --git a/typechain-types/contracts/prototypes/Gateway.ts b/typechain-types/contracts/prototypes/Gateway.ts index 9edf92c6..21eda719 100644 --- a/typechain-types/contracts/prototypes/Gateway.ts +++ b/typechain-types/contracts/prototypes/Gateway.ts @@ -33,7 +33,14 @@ export interface GatewayInterface extends utils.Interface { "custody()": FunctionFragment; "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; }; getFunction( @@ -41,7 +48,14 @@ export interface GatewayInterface extends utils.Interface { | "custody" | "execute" | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" | "setCustody" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" ): FunctionFragment; encodeFunctionData(functionFragment: "custody", values?: undefined): string; @@ -58,10 +72,35 @@ export interface GatewayInterface extends utils.Interface { PromiseOrValue ] ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; encodeFunctionData( functionFragment: "setCustody", values: [PromiseOrValue] ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; @@ -69,16 +108,66 @@ export interface GatewayInterface extends utils.Interface { functionFragment: "executeWithERC20", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; "Executed(address,uint256,bytes)": EventFragment; "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; }; + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; } +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; export interface ExecutedEventObject { destination: string; @@ -106,6 +195,32 @@ export type ExecutedWithERC20Event = TypedEvent< export type ExecutedWithERC20EventFilter = TypedEventFilter; +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + export interface Gateway extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; @@ -149,10 +264,38 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; }; custody(overrides?: CallOverrides): Promise; @@ -171,11 +314,39 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + callStatic: { custody(overrides?: CallOverrides): Promise; @@ -193,13 +364,53 @@ export interface Gateway extends BaseContract { overrides?: CallOverrides ): Promise; + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + setCustody( _custody: PromiseOrValue, overrides?: CallOverrides ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; }; filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + "Executed(address,uint256,bytes)"( destination?: PromiseOrValue | null, value?: null, @@ -223,6 +434,25 @@ export interface Gateway extends BaseContract { amount?: null, data?: null ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; }; estimateGas: { @@ -242,10 +472,38 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; }; populateTransaction: { @@ -265,9 +523,37 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; }; } diff --git a/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts new file mode 100644 index 00000000..d870814a --- /dev/null +++ b/typechain-types/contracts/prototypes/GatewayUpgradeTest.ts @@ -0,0 +1,559 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface GatewayUpgradeTestInterface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20V2(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20V2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20V2EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20V2Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20V2EventObject +>; + +export type ExecutedWithERC20V2EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayUpgradeTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayUpgradeTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20V2(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + ExecutedWithERC20V2( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/GatewayV2.sol/Gateway.ts b/typechain-types/contracts/prototypes/GatewayV2.sol/Gateway.ts new file mode 100644 index 00000000..52121e90 --- /dev/null +++ b/typechain-types/contracts/prototypes/GatewayV2.sol/Gateway.ts @@ -0,0 +1,559 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayInterface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20V2(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20V2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20V2EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20V2Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20V2EventObject +>; + +export type ExecutedWithERC20V2EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface Gateway extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20V2(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + ExecutedWithERC20V2( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/GatewayV2.sol/GatewayV2.ts b/typechain-types/contracts/prototypes/GatewayV2.sol/GatewayV2.ts new file mode 100644 index 00000000..a3b2787d --- /dev/null +++ b/typechain-types/contracts/prototypes/GatewayV2.sol/GatewayV2.ts @@ -0,0 +1,559 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayV2Interface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20V2(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20V2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20V2EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20V2Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20V2EventObject +>; + +export type ExecutedWithERC20V2EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayV2 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayV2Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20V2(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + ExecutedWithERC20V2( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/GatewayV2.sol/index.ts b/typechain-types/contracts/prototypes/GatewayV2.sol/index.ts new file mode 100644 index 00000000..cc062d9c --- /dev/null +++ b/typechain-types/contracts/prototypes/GatewayV2.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { Gateway } from "./Gateway"; +export type { GatewayV2 } from "./GatewayV2"; diff --git a/typechain-types/contracts/prototypes/GatewayV2.ts b/typechain-types/contracts/prototypes/GatewayV2.ts new file mode 100644 index 00000000..9d367e00 --- /dev/null +++ b/typechain-types/contracts/prototypes/GatewayV2.ts @@ -0,0 +1,559 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface GatewayV2Interface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20V2(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20V2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20V2EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20V2Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20V2EventObject +>; + +export type ExecutedWithERC20V2EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayV2 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayV2Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20V2(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + ExecutedWithERC20V2( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20V2EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index 420d0e89..8e3200c1 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -1,7 +1,10 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +import type * as interfacesSol from "./interfaces.sol"; +export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { Gateway } from "./Gateway"; +export type { GatewayUpgradeTest } from "./GatewayUpgradeTest"; export type { Receiver } from "./Receiver"; export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts new file mode 100644 index 00000000..969095cb --- /dev/null +++ b/typechain-types/contracts/prototypes/interfaces.sol/IGateway.ts @@ -0,0 +1,165 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IGatewayInterface extends utils.Interface { + functions: { + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "execute" | "executeWithERC20" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IGateway extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/interfaces.sol/index.ts new file mode 100644 index 00000000..878cfe66 --- /dev/null +++ b/typechain-types/contracts/prototypes/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IGateway } from "./IGateway"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory.ts new file mode 100644 index 00000000..c4c6be30 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory.ts @@ -0,0 +1,91 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + OwnableUpgradeable, + OwnableUpgradeableInterface, +} from "../../../../@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class OwnableUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): OwnableUpgradeableInterface { + return new utils.Interface(_abi) as OwnableUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): OwnableUpgradeable { + return new Contract(address, _abi, signerOrProvider) as OwnableUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/index.ts new file mode 100644 index 00000000..bf4b29cc --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/access/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { OwnableUpgradeable__factory } from "./OwnableUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/index.ts new file mode 100644 index 00000000..aedb8d87 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as access from "./access"; +export * as interfaces from "./interfaces"; +export * as proxy from "./proxy"; +export * as utils from "./utils"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable__factory.ts new file mode 100644 index 00000000..ed24d198 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable__factory.ts @@ -0,0 +1,71 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC1967Upgradeable, + IERC1967UpgradeableInterface, +} from "../../../../@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, +] as const; + +export class IERC1967Upgradeable__factory { + static readonly abi = _abi; + static createInterface(): IERC1967UpgradeableInterface { + return new utils.Interface(_abi) as IERC1967UpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC1967Upgradeable { + return new Contract(address, _abi, signerOrProvider) as IERC1967Upgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable__factory.ts new file mode 100644 index 00000000..6ad7eecf --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable__factory.ts @@ -0,0 +1,43 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC1822ProxiableUpgradeable, + IERC1822ProxiableUpgradeableInterface, +} from "../../../../../@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable"; + +const _abi = [ + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class IERC1822ProxiableUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): IERC1822ProxiableUpgradeableInterface { + return new utils.Interface(_abi) as IERC1822ProxiableUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC1822ProxiableUpgradeable { + return new Contract( + address, + _abi, + signerOrProvider + ) as IERC1822ProxiableUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts new file mode 100644 index 00000000..7db58c5b --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IERC1822ProxiableUpgradeable__factory } from "./IERC1822ProxiableUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/index.ts new file mode 100644 index 00000000..d81fc631 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/interfaces/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as draftIerc1822UpgradeableSol from "./draft-IERC1822Upgradeable.sol"; +export { IERC1967Upgradeable__factory } from "./IERC1967Upgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable__factory.ts new file mode 100644 index 00000000..5a270bdb --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable__factory.ts @@ -0,0 +1,88 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ERC1967UpgradeUpgradeable, + ERC1967UpgradeUpgradeableInterface, +} from "../../../../../@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, +] as const; + +export class ERC1967UpgradeUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): ERC1967UpgradeUpgradeableInterface { + return new utils.Interface(_abi) as ERC1967UpgradeUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ERC1967UpgradeUpgradeable { + return new Contract( + address, + _abi, + signerOrProvider + ) as ERC1967UpgradeUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts new file mode 100644 index 00000000..12fe8742 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { ERC1967UpgradeUpgradeable__factory } from "./ERC1967UpgradeUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable__factory.ts new file mode 100644 index 00000000..fe2170dd --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable__factory.ts @@ -0,0 +1,39 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IBeaconUpgradeable, + IBeaconUpgradeableInterface, +} from "../../../../../@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable"; + +const _abi = [ + { + inputs: [], + name: "implementation", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class IBeaconUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): IBeaconUpgradeableInterface { + return new utils.Interface(_abi) as IBeaconUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IBeaconUpgradeable { + return new Contract(address, _abi, signerOrProvider) as IBeaconUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts new file mode 100644 index 00000000..5b72d318 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/beacon/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IBeaconUpgradeable__factory } from "./IBeaconUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/index.ts new file mode 100644 index 00000000..4ac4c845 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as erc1967 from "./ERC1967"; +export * as beacon from "./beacon"; +export * as utils from "./utils"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory.ts new file mode 100644 index 00000000..2f225279 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory.ts @@ -0,0 +1,39 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + Initializable, + InitializableInterface, +} from "../../../../../@openzeppelin/contracts-upgradeable/proxy/utils/Initializable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, +] as const; + +export class Initializable__factory { + static readonly abi = _abi; + static createInterface(): InitializableInterface { + return new utils.Interface(_abi) as InitializableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Initializable { + return new Contract(address, _abi, signerOrProvider) as Initializable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory.ts new file mode 100644 index 00000000..ba25b481 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory.ts @@ -0,0 +1,128 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + UUPSUpgradeable, + UUPSUpgradeableInterface, +} from "../../../../../@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +export class UUPSUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): UUPSUpgradeableInterface { + return new utils.Interface(_abi) as UUPSUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): UUPSUpgradeable { + return new Contract(address, _abi, signerOrProvider) as UUPSUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts new file mode 100644 index 00000000..a192d15d --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/proxy/utils/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { Initializable__factory } from "./Initializable__factory"; +export { UUPSUpgradeable__factory } from "./UUPSUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory.ts new file mode 100644 index 00000000..6b02b4d3 --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory.ts @@ -0,0 +1,39 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ContextUpgradeable, + ContextUpgradeableInterface, +} from "../../../../@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, +] as const; + +export class ContextUpgradeable__factory { + static readonly abi = _abi; + static createInterface(): ContextUpgradeableInterface { + return new utils.Interface(_abi) as ContextUpgradeableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ContextUpgradeable { + return new Contract(address, _abi, signerOrProvider) as ContextUpgradeable; + } +} diff --git a/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/index.ts b/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/index.ts new file mode 100644 index 00000000..3ff42aef --- /dev/null +++ b/typechain-types/factories/@openzeppelin/contracts-upgradeable/utils/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { ContextUpgradeable__factory } from "./ContextUpgradeable__factory"; diff --git a/typechain-types/factories/@openzeppelin/index.ts b/typechain-types/factories/@openzeppelin/index.ts index 6397da09..6923c15a 100644 --- a/typechain-types/factories/@openzeppelin/index.ts +++ b/typechain-types/factories/@openzeppelin/index.ts @@ -2,3 +2,4 @@ /* tslint:disable */ /* eslint-disable */ export * as contracts from "./contracts"; +export * as contractsUpgradeable from "./contracts-upgradeable"; diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index a994cff3..60aa0793 100644 --- a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -82,7 +82,7 @@ const _abi = [ name: "gateway", outputs: [ { - internalType: "contract Gateway", + internalType: "contract IGateway", name: "", type: "address", }, @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts new file mode 100644 index 00000000..09a34d87 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/GatewayUpgradeTest__factory.ts @@ -0,0 +1,374 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + GatewayUpgradeTest, + GatewayUpgradeTestInterface, +} from "../../../contracts/prototypes/GatewayUpgradeTest"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20V2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayUpgradeTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayUpgradeTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayUpgradeTest__factory extends ContractFactory { + constructor(...args: GatewayUpgradeTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayUpgradeTest { + return super.attach(address) as GatewayUpgradeTest; + } + override connect(signer: Signer): GatewayUpgradeTest__factory { + return super.connect(signer) as GatewayUpgradeTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayUpgradeTestInterface { + return new utils.Interface(_abi) as GatewayUpgradeTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayUpgradeTest { + return new Contract(address, _abi, signerOrProvider) as GatewayUpgradeTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/GatewayV2.sol/GatewayV2__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/GatewayV2__factory.ts new file mode 100644 index 00000000..9f8e5fb0 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/GatewayV2__factory.ts @@ -0,0 +1,374 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayV2, + GatewayV2Interface, +} from "../../../../contracts/prototypes/GatewayV2.sol/GatewayV2"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20V2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayV2ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayV2ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayV2__factory extends ContractFactory { + constructor(...args: GatewayV2ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayV2 { + return super.attach(address) as GatewayV2; + } + override connect(signer: Signer): GatewayV2__factory { + return super.connect(signer) as GatewayV2__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayV2Interface { + return new utils.Interface(_abi) as GatewayV2Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayV2 { + return new Contract(address, _abi, signerOrProvider) as GatewayV2; + } +} diff --git a/typechain-types/factories/contracts/prototypes/GatewayV2.sol/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/Gateway__factory.ts new file mode 100644 index 00000000..509a9f46 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/Gateway__factory.ts @@ -0,0 +1,374 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + Gateway, + GatewayInterface, +} from "../../../../contracts/prototypes/GatewayV2.sol/Gateway"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20V2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Gateway__factory extends ContractFactory { + constructor(...args: GatewayConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): Gateway { + return super.attach(address) as Gateway; + } + override connect(signer: Signer): Gateway__factory { + return super.connect(signer) as Gateway__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayInterface { + return new utils.Interface(_abi) as GatewayInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Gateway { + return new Contract(address, _abi, signerOrProvider) as Gateway; + } +} diff --git a/typechain-types/factories/contracts/prototypes/GatewayV2.sol/index.ts b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/index.ts new file mode 100644 index 00000000..3e3376ed --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/GatewayV2.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { Gateway__factory } from "./Gateway__factory"; +export { GatewayV2__factory } from "./GatewayV2__factory"; diff --git a/typechain-types/factories/contracts/prototypes/GatewayV2__factory.ts b/typechain-types/factories/contracts/prototypes/GatewayV2__factory.ts new file mode 100644 index 00000000..b07067d2 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/GatewayV2__factory.ts @@ -0,0 +1,374 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + GatewayV2, + GatewayV2Interface, +} from "../../../contracts/prototypes/GatewayV2"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20V2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayV2ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayV2ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayV2__factory extends ContractFactory { + constructor(...args: GatewayV2ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayV2 { + return super.attach(address) as GatewayV2; + } + override connect(signer: Signer): GatewayV2__factory { + return super.connect(signer) as GatewayV2__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayV2Interface { + return new utils.Interface(_abi) as GatewayV2Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayV2 { + return new Contract(address, _abi, signerOrProvider) as GatewayV2; + } +} diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 03a4c1ce..424b3e6f 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -10,11 +10,48 @@ import type { } from "../../../contracts/prototypes/Gateway"; const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, { inputs: [], name: "ExecutionFailed", type: "error", }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, { anonymous: false, inputs: [ @@ -71,12 +108,57 @@ const _abi = [ name: "ExecutedWithERC20", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, { inputs: [], name: "custody", outputs: [ { - internalType: "contract ERC20CustodyNew", + internalType: "address", name: "", type: "address", }, @@ -142,6 +224,46 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -155,10 +277,54 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 9dfdd555..6fb60d1c 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -1,7 +1,9 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { Gateway__factory } from "./Gateway__factory"; +export { GatewayUpgradeTest__factory } from "./GatewayUpgradeTest__factory"; export { Receiver__factory } from "./Receiver__factory"; export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts new file mode 100644 index 00000000..20c69449 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/IGateway__factory.ts @@ -0,0 +1,84 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGateway, + IGatewayInterface, +} from "../../../../contracts/prototypes/interfaces.sol/IGateway"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGateway__factory { + static readonly abi = _abi; + static createInterface(): IGatewayInterface { + return new utils.Interface(_abi) as IGatewayInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGateway { + return new Contract(address, _abi, signerOrProvider) as IGateway; + } +} diff --git a/typechain-types/factories/contracts/prototypes/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/interfaces.sol/index.ts new file mode 100644 index 00000000..d3a5c88a --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IGateway__factory } from "./IGateway__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 06d7d730..e98d4f69 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -12,6 +12,38 @@ import * as Contracts from "."; declare module "hardhat/types/runtime" { interface HardhatEthersHelpers extends HardhatEthersHelpersBase { + getContractFactory( + name: "OwnableUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC1822ProxiableUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC1967Upgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IBeaconUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ERC1967UpgradeUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "Initializable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "UUPSUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ContextUpgradeable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "Ownable", signerOrOptions?: ethers.Signer | FactoryOptions @@ -308,6 +340,14 @@ declare module "hardhat/types/runtime" { name: "Gateway", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayUpgradeTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IGateway", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "Receiver", signerOrOptions?: ethers.Signer | FactoryOptions @@ -385,6 +425,46 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractAt( + name: "OwnableUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC1822ProxiableUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC1967Upgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IBeaconUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ERC1967UpgradeUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "Initializable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "UUPSUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ContextUpgradeable", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "Ownable", address: string, @@ -755,6 +835,16 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayUpgradeTest", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IGateway", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "Receiver", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 7ad48bc2..6f13ad23 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -8,6 +8,22 @@ export type { uniswap }; import type * as contracts from "./contracts"; export type { contracts }; export * as factories from "./factories"; +export type { OwnableUpgradeable } from "./@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable"; +export { OwnableUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory"; +export type { IERC1822ProxiableUpgradeable } from "./@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable"; +export { IERC1822ProxiableUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol/IERC1822ProxiableUpgradeable__factory"; +export type { IERC1967Upgradeable } from "./@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable"; +export { IERC1967Upgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/interfaces/IERC1967Upgradeable__factory"; +export type { IBeaconUpgradeable } from "./@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable"; +export { IBeaconUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable__factory"; +export type { ERC1967UpgradeUpgradeable } from "./@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable"; +export { ERC1967UpgradeUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable__factory"; +export type { Initializable } from "./@openzeppelin/contracts-upgradeable/proxy/utils/Initializable"; +export { Initializable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/utils/Initializable__factory"; +export type { UUPSUpgradeable } from "./@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable"; +export { UUPSUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable__factory"; +export type { ContextUpgradeable } from "./@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable"; +export { ContextUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable__factory"; export type { Ownable } from "./@openzeppelin/contracts/access/Ownable"; export { Ownable__factory } from "./factories/@openzeppelin/contracts/access/Ownable__factory"; export type { Ownable2Step } from "./@openzeppelin/contracts/access/Ownable2Step"; @@ -144,6 +160,10 @@ export type { ERC20CustodyNew } from "./contracts/prototypes/ERC20CustodyNew"; export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/ERC20CustodyNew__factory"; export type { Gateway } from "./contracts/prototypes/Gateway"; export { Gateway__factory } from "./factories/contracts/prototypes/Gateway__factory"; +export type { GatewayUpgradeTest } from "./contracts/prototypes/GatewayUpgradeTest"; +export { GatewayUpgradeTest__factory } from "./factories/contracts/prototypes/GatewayUpgradeTest__factory"; +export type { IGateway } from "./contracts/prototypes/interfaces.sol/IGateway"; +export { IGateway__factory } from "./factories/contracts/prototypes/interfaces.sol/IGateway__factory"; export type { Receiver } from "./contracts/prototypes/Receiver"; export { Receiver__factory } from "./factories/contracts/prototypes/Receiver__factory"; export type { TestERC20 } from "./contracts/prototypes/TestERC20"; diff --git a/yarn.lock b/yarn.lock index 9280f022..81d54ca7 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2,6 +2,39 @@ # yarn lockfile v1 +"@aws-crypto/sha256-js@1.2.2": + version "1.2.2" + resolved "https://registry.yarnpkg.com/@aws-crypto/sha256-js/-/sha256-js-1.2.2.tgz#02acd1a1fda92896fc5a28ec7c6e164644ea32fc" + integrity sha512-Nr1QJIbW/afYYGzYvrF70LtaHrIRtd4TNAglX8BvlfxJLZ45SAmueIKYl5tWoNBPzp65ymXGFK0Bb1vZUpuc9g== + dependencies: + "@aws-crypto/util" "^1.2.2" + "@aws-sdk/types" "^3.1.0" + tslib "^1.11.1" + +"@aws-crypto/util@^1.2.2": + version "1.2.2" + resolved "https://registry.yarnpkg.com/@aws-crypto/util/-/util-1.2.2.tgz#b28f7897730eb6538b21c18bd4de22d0ea09003c" + integrity sha512-H8PjG5WJ4wz0UXAFXeJjWCW1vkvIJ3qUUD+rGRwJ2/hj+xT58Qle2MTql/2MGzkU+1JLAFuR6aJpLAjHwhmwwg== + dependencies: + "@aws-sdk/types" "^3.1.0" + "@aws-sdk/util-utf8-browser" "^3.0.0" + tslib "^1.11.1" + +"@aws-sdk/types@^3.1.0": + version "3.598.0" + resolved "https://registry.yarnpkg.com/@aws-sdk/types/-/types-3.598.0.tgz#b840d2446dee19a2a4731e6166f2327915d846db" + integrity sha512-742uRl6z7u0LFmZwDrFP6r1wlZcgVPw+/TilluDJmCAR8BgRw3IR+743kUXKBGd8QZDRW2n6v/PYsi/AWCDDMQ== + dependencies: + "@smithy/types" "^3.1.0" + tslib "^2.6.2" + +"@aws-sdk/util-utf8-browser@^3.0.0": + version "3.259.0" + resolved "https://registry.yarnpkg.com/@aws-sdk/util-utf8-browser/-/util-utf8-browser-3.259.0.tgz#3275a6f5eb334f96ca76635b961d3c50259fd9ff" + integrity sha512-UvFa/vR+e19XookZF8RzFZBrw2EUkQWxiBW0yYQAhvk3C+QVGl0H3ouca8LDBlBfQKXwmW3huo/59H8rwb1wJw== + dependencies: + tslib "^2.3.1" + "@babel/code-frame@^7.0.0": version "7.21.4" resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.21.4.tgz" @@ -1534,6 +1567,11 @@ resolved "https://registry.npmjs.org/@nomiclabs/hardhat-waffle/-/hardhat-waffle-2.0.5.tgz" integrity sha512-U1RH9OQ1mWYQfb+moX5aTgGjpVVlOcpiFI47wwnaGG4kLhcTy90cNiapoqZenxcRAITVbr0/+QSduINL5EsUIQ== +"@openzeppelin/contracts-upgradeable@^4.8.3": + version "4.9.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.9.6.tgz#38b21708a719da647de4bb0e4802ee235a0d24df" + integrity sha512-m4iHazOsOCv1DgM7eD7GupTJ+NFVujRZt1wzddDPSVGpWdKq1SKkla5htKG7+IS4d2XOCtzkUNwRZ7Vq5aEUMA== + "@openzeppelin/contracts@3.4.2-solc-0.7": version "3.4.2-solc-0.7" resolved "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-3.4.2-solc-0.7.tgz" @@ -1549,6 +1587,54 @@ resolved "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-4.8.3.tgz" integrity sha512-bQHV8R9Me8IaJoJ2vPG4rXcL7seB7YVuskr4f+f5RyOStSZetwzkWtoqDMl5erkBJy0lDRUnIR2WIkPiC0GJlg== +"@openzeppelin/defender-base-client@^1.46.0": + version "1.54.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/defender-base-client/-/defender-base-client-1.54.6.tgz#b65a90dba49375ac1439d638832382344067a0b9" + integrity sha512-PTef+rMxkM5VQ7sLwLKSjp2DBakYQd661ZJiSRywx+q/nIpm3B/HYGcz5wPZCA5O/QcEP6TatXXDoeMwimbcnw== + dependencies: + amazon-cognito-identity-js "^6.0.1" + async-retry "^1.3.3" + axios "^1.4.0" + lodash "^4.17.19" + node-fetch "^2.6.0" + +"@openzeppelin/hardhat-upgrades@1.28.0": + version "1.28.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/hardhat-upgrades/-/hardhat-upgrades-1.28.0.tgz#6361f313a8a879d8a08a5e395acf0933bc190950" + integrity sha512-7sb/Jf+X+uIufOBnmHR0FJVWuxEs2lpxjJnLNN6eCJCP8nD0v+Ot5lTOW2Qb/GFnh+fLvJtEkhkowz4ZQ57+zQ== + dependencies: + "@openzeppelin/defender-base-client" "^1.46.0" + "@openzeppelin/platform-deploy-client" "^0.8.0" + "@openzeppelin/upgrades-core" "^1.27.0" + chalk "^4.1.0" + debug "^4.1.1" + proper-lockfile "^4.1.1" + +"@openzeppelin/platform-deploy-client@^0.8.0": + version "0.8.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/platform-deploy-client/-/platform-deploy-client-0.8.0.tgz#af6596275a19c283d6145f0128cc1247d18223c1" + integrity sha512-POx3AsnKwKSV/ZLOU/gheksj0Lq7Is1q2F3pKmcFjGZiibf+4kjGxr4eSMrT+2qgKYZQH1ZLQZ+SkbguD8fTvA== + dependencies: + "@ethersproject/abi" "^5.6.3" + "@openzeppelin/defender-base-client" "^1.46.0" + axios "^0.21.2" + lodash "^4.17.19" + node-fetch "^2.6.0" + +"@openzeppelin/upgrades-core@^1.27.0": + version "1.34.1" + resolved "https://registry.yarnpkg.com/@openzeppelin/upgrades-core/-/upgrades-core-1.34.1.tgz#660301692e706c7e701395467267128cc43c1de9" + integrity sha512-LV3hHm60htmP3HJjn2VoGqXNPn1RLFSSInRyXNbm15Z2oWKGxOfAWSC4+okRckum0yVB5g3k4/SEyqjsJRB07A== + dependencies: + cbor "^9.0.0" + chalk "^4.1.0" + compare-versions "^6.0.0" + debug "^4.1.1" + ethereumjs-util "^7.0.3" + minimist "^1.2.7" + proper-lockfile "^4.1.1" + solidity-ast "^0.4.51" + "@pnpm/config.env-replace@^1.1.0": version "1.1.0" resolved "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz" @@ -1702,6 +1788,13 @@ resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz" integrity sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g== +"@smithy/types@^3.1.0": + version "3.2.0" + resolved "https://registry.yarnpkg.com/@smithy/types/-/types-3.2.0.tgz#1350fe8a50d5e35e12ffb34be46d946860b2b5ab" + integrity sha512-cKyeKAPazZRVqm7QPvcPD2jEIt2wqDPAL1KJKb0f/5I7uhollvsWZuZKLclmyP6a+Jwmr3OV3t+X0pZUUHS9BA== + dependencies: + tslib "^2.6.2" + "@solidity-parser/parser@^0.14.0", "@solidity-parser/parser@^0.14.1": version "0.14.5" resolved "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.5.tgz" @@ -2270,6 +2363,17 @@ ajv@^8.0.1: require-from-string "^2.0.2" uri-js "^4.2.2" +amazon-cognito-identity-js@^6.0.1: + version "6.3.12" + resolved "https://registry.yarnpkg.com/amazon-cognito-identity-js/-/amazon-cognito-identity-js-6.3.12.tgz#af73df033094ad4c679c19cf6122b90058021619" + integrity sha512-s7NKDZgx336cp+oDeUtB2ZzT8jWJp/v2LWuYl+LQtMEODe22RF1IJ4nRiDATp+rp1pTffCZcm44Quw4jx2bqNg== + dependencies: + "@aws-crypto/sha256-js" "1.2.2" + buffer "4.9.2" + fast-base64-decode "^1.0.0" + isomorphic-unfetch "^3.0.0" + js-cookie "^2.2.1" + amdefine@>=0.0.4: version "1.0.1" resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz" @@ -2409,6 +2513,14 @@ array-buffer-byte-length@^1.0.0: call-bind "^1.0.2" is-array-buffer "^3.0.1" +array-buffer-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz#1e5583ec16763540a27ae52eed99ff899223568f" + integrity sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg== + dependencies: + call-bind "^1.0.5" + is-array-buffer "^3.0.4" + array-includes@^3.1.6: version "3.1.6" resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz" @@ -2440,6 +2552,18 @@ array-unique@^0.3.2: resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz" integrity sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ== +array.prototype.findlast@^1.2.2: + version "1.2.5" + resolved "https://registry.yarnpkg.com/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz#3e4fbcb30a15a7f5bf64cf2faae22d139c2e4904" + integrity sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-shim-unscopables "^1.0.2" + array.prototype.flat@^1.2.3, array.prototype.flat@^1.3.1: version "1.3.1" resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz" @@ -2471,6 +2595,20 @@ array.prototype.reduce@^1.0.5: es-array-method-boxes-properly "^1.0.0" is-string "^1.0.7" +arraybuffer.prototype.slice@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz#097972f4255e41bc3425e37dc3f6421cf9aefde6" + integrity sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A== + dependencies: + array-buffer-byte-length "^1.0.1" + call-bind "^1.0.5" + define-properties "^1.2.1" + es-abstract "^1.22.3" + es-errors "^1.2.1" + get-intrinsic "^1.2.3" + is-array-buffer "^3.0.4" + is-shared-array-buffer "^1.0.2" + arrify@^1.0.0, arrify@^1.0.1: version "1.0.1" resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz" @@ -2525,6 +2663,13 @@ async-eventemitter@^0.2.4: dependencies: async "^2.4.0" +async-retry@^1.3.3: + version "1.3.3" + resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.3.3.tgz#0e7f36c04d8478e7a58bdbed80cedf977785f280" + integrity sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw== + dependencies: + retry "0.13.1" + async@1.x: version "1.5.2" resolved "https://registry.npmjs.org/async/-/async-1.5.2.tgz" @@ -2557,6 +2702,13 @@ available-typed-arrays@^1.0.5: resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz" integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw== +available-typed-arrays@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz#a5cc375d6a03c2efc87a553f3e0b1522def14846" + integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ== + dependencies: + possible-typed-array-names "^1.0.0" + aws-sign2@~0.7.0: version "0.7.0" resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz" @@ -2567,6 +2719,22 @@ aws4@^1.8.0: resolved "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz" integrity sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg== +axios@^0.21.2: + version "0.21.4" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.4.tgz#c67b90dc0568e5c1cf2b0b858c43ba28e2eda575" + integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg== + dependencies: + follow-redirects "^1.14.0" + +axios@^1.4.0: + version "1.7.2" + resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.2.tgz#b625db8a7051fbea61c35a3cbb3a1daa7b9c7621" + integrity sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw== + dependencies: + follow-redirects "^1.15.6" + form-data "^4.0.0" + proxy-from-env "^1.1.0" + axios@^1.6.5: version "1.6.5" resolved "https://registry.npmjs.org/axios/-/axios-1.6.5.tgz" @@ -2596,7 +2764,7 @@ base-x@^3.0.2: dependencies: safe-buffer "^5.0.1" -base64-js@^1.3.1: +base64-js@^1.0.2, base64-js@^1.3.1: version "1.5.1" resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz" integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== @@ -2830,6 +2998,15 @@ buffer-xor@^2.0.1: dependencies: safe-buffer "^5.1.1" +buffer@4.9.2: + version "4.9.2" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.2.tgz#230ead344002988644841ab0244af8c44bbe3ef8" + integrity sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg== + dependencies: + base64-js "^1.0.2" + ieee754 "^1.1.4" + isarray "^1.0.0" + buffer@^5.5.0, buffer@^5.6.0: version "5.7.1" resolved "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz" @@ -2906,6 +3083,17 @@ call-bind@^1.0.0, call-bind@^1.0.2: function-bind "^1.1.1" get-intrinsic "^1.0.2" +call-bind@^1.0.5, call-bind@^1.0.6, call-bind@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.7.tgz#06016599c40c56498c18769d2730be242b6fa3b9" + integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w== + dependencies: + es-define-property "^1.0.0" + es-errors "^1.3.0" + function-bind "^1.1.2" + get-intrinsic "^1.2.4" + set-function-length "^1.2.1" + callsites@^3.0.0: version "3.1.0" resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz" @@ -2962,6 +3150,13 @@ cbor@^8.1.0: dependencies: nofilter "^3.1.0" +cbor@^9.0.0: + version "9.0.2" + resolved "https://registry.yarnpkg.com/cbor/-/cbor-9.0.2.tgz#536b4f2d544411e70ec2b19a2453f10f83cd9fdb" + integrity sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ== + dependencies: + nofilter "^3.1.0" + chai-as-promised@^7.1.1: version "7.1.1" resolved "https://registry.npmjs.org/chai-as-promised/-/chai-as-promised-7.1.1.tgz" @@ -3263,6 +3458,11 @@ commander@^8.1.0: resolved "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz" integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww== +compare-versions@^6.0.0: + version "6.1.0" + resolved "https://registry.yarnpkg.com/compare-versions/-/compare-versions-6.1.0.tgz#3f2131e3ae93577df111dba133e6db876ffe127a" + integrity sha512-LNZQXhqUvqUTotpZ00qLSaify3b4VFD588aRr8MKFw4CMUr98ytzCW5wDH5qx/DEY5kCDXcbcRuCqL0szEf2tg== + component-emitter@^1.2.1: version "1.3.0" resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz" @@ -3436,6 +3636,33 @@ dashdash@^1.12.0: dependencies: assert-plus "^1.0.0" +data-view-buffer@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/data-view-buffer/-/data-view-buffer-1.0.1.tgz#8ea6326efec17a2e42620696e671d7d5a8bc66b2" + integrity sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +data-view-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/data-view-byte-length/-/data-view-byte-length-1.0.1.tgz#90721ca95ff280677eb793749fce1011347669e2" + integrity sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ== + dependencies: + call-bind "^1.0.7" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +data-view-byte-offset@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz#5e0bbfb4828ed2d1b9b400cd8a7d119bca0ff18a" + integrity sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-data-view "^1.0.1" + death@^1.1.0: version "1.1.0" resolved "https://registry.npmjs.org/death/-/death-1.1.0.tgz" @@ -3541,6 +3768,15 @@ deferred-leveldown@~5.3.0: abstract-leveldown "~6.2.1" inherits "^2.0.3" +define-data-property@^1.0.1, define-data-property@^1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e" + integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A== + dependencies: + es-define-property "^1.0.0" + es-errors "^1.3.0" + gopd "^1.0.1" + define-properties@^1.1.2, define-properties@^1.1.3, define-properties@^1.1.4: version "1.2.0" resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz" @@ -3549,6 +3785,15 @@ define-properties@^1.1.2, define-properties@^1.1.3, define-properties@^1.1.4: has-property-descriptors "^1.0.0" object-keys "^1.1.1" +define-properties@^1.2.0, define-properties@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c" + integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg== + dependencies: + define-data-property "^1.0.1" + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + define-property@^0.2.5: version "0.2.5" resolved "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz" @@ -3805,11 +4050,82 @@ es-abstract@^1.19.0, es-abstract@^1.20.4: unbox-primitive "^1.0.2" which-typed-array "^1.1.9" +es-abstract@^1.22.1, es-abstract@^1.22.3, es-abstract@^1.23.0, es-abstract@^1.23.2: + version "1.23.3" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.23.3.tgz#8f0c5a35cd215312573c5a27c87dfd6c881a0aa0" + integrity sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A== + dependencies: + array-buffer-byte-length "^1.0.1" + arraybuffer.prototype.slice "^1.0.3" + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + data-view-buffer "^1.0.1" + data-view-byte-length "^1.0.1" + data-view-byte-offset "^1.0.0" + es-define-property "^1.0.0" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-set-tostringtag "^2.0.3" + es-to-primitive "^1.2.1" + function.prototype.name "^1.1.6" + get-intrinsic "^1.2.4" + get-symbol-description "^1.0.2" + globalthis "^1.0.3" + gopd "^1.0.1" + has-property-descriptors "^1.0.2" + has-proto "^1.0.3" + has-symbols "^1.0.3" + hasown "^2.0.2" + internal-slot "^1.0.7" + is-array-buffer "^3.0.4" + is-callable "^1.2.7" + is-data-view "^1.0.1" + is-negative-zero "^2.0.3" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.3" + is-string "^1.0.7" + is-typed-array "^1.1.13" + is-weakref "^1.0.2" + object-inspect "^1.13.1" + object-keys "^1.1.1" + object.assign "^4.1.5" + regexp.prototype.flags "^1.5.2" + safe-array-concat "^1.1.2" + safe-regex-test "^1.0.3" + string.prototype.trim "^1.2.9" + string.prototype.trimend "^1.0.8" + string.prototype.trimstart "^1.0.8" + typed-array-buffer "^1.0.2" + typed-array-byte-length "^1.0.1" + typed-array-byte-offset "^1.0.2" + typed-array-length "^1.0.6" + unbox-primitive "^1.0.2" + which-typed-array "^1.1.15" + es-array-method-boxes-properly@^1.0.0: version "1.0.0" resolved "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz" integrity sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA== +es-define-property@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.0.tgz#c7faefbdff8b2696cf5f46921edfb77cc4ba3845" + integrity sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ== + dependencies: + get-intrinsic "^1.2.4" + +es-errors@^1.2.1, es-errors@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f" + integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== + +es-object-atoms@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-object-atoms/-/es-object-atoms-1.0.0.tgz#ddb55cd47ac2e240701260bc2a8e31ecb643d941" + integrity sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw== + dependencies: + es-errors "^1.3.0" + es-set-tostringtag@^2.0.1: version "2.0.1" resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz" @@ -3819,6 +4135,15 @@ es-set-tostringtag@^2.0.1: has "^1.0.3" has-tostringtag "^1.0.0" +es-set-tostringtag@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz#8bb60f0a440c2e4281962428438d58545af39777" + integrity sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ== + dependencies: + get-intrinsic "^1.2.4" + has-tostringtag "^1.0.2" + hasown "^2.0.1" + es-shim-unscopables@^1.0.0: version "1.0.0" resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz" @@ -3826,6 +4151,13 @@ es-shim-unscopables@^1.0.0: dependencies: has "^1.0.3" +es-shim-unscopables@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz#1f6942e71ecc7835ed1c8a83006d8771a63a3763" + integrity sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw== + dependencies: + hasown "^2.0.0" + es-to-primitive@^1.2.1: version "1.2.1" resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz" @@ -4225,7 +4557,7 @@ ethereumjs-util@^6.0.0, ethereumjs-util@^6.2.1: ethjs-util "0.1.6" rlp "^2.2.3" -ethereumjs-util@^7.1.0, ethereumjs-util@^7.1.1, ethereumjs-util@^7.1.3, ethereumjs-util@^7.1.4, ethereumjs-util@^7.1.5: +ethereumjs-util@^7.0.3, ethereumjs-util@^7.1.0, ethereumjs-util@^7.1.1, ethereumjs-util@^7.1.3, ethereumjs-util@^7.1.4, ethereumjs-util@^7.1.5: version "7.1.5" resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz" integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg== @@ -4457,6 +4789,11 @@ extsprintf@^1.2.0: resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz" integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA== +fast-base64-decode@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fast-base64-decode/-/fast-base64-decode-1.0.0.tgz#b434a0dd7d92b12b43f26819300d2dafb83ee418" + integrity sha512-qwaScUgUGBYeDNRnbc/KyllVU88Jk1pRHPStuF/lO7B0/RTRLj7U0lkdTAutlBblY08rwZDff6tNU9cjv6j//Q== + fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: version "3.1.3" resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz" @@ -4627,6 +4964,11 @@ follow-redirects@^1.12.1: resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz" integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA== +follow-redirects@^1.14.0, follow-redirects@^1.15.6: + version "1.15.6" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b" + integrity sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA== + follow-redirects@^1.15.4: version "1.15.4" resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz" @@ -4786,6 +5128,11 @@ function-bind@^1.1.1: resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz" integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== +function-bind@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== + function.prototype.name@^1.1.5: version "1.1.5" resolved "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz" @@ -4796,12 +5143,22 @@ function.prototype.name@^1.1.5: es-abstract "^1.19.0" functions-have-names "^1.2.2" +function.prototype.name@^1.1.6: + version "1.1.6" + resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.6.tgz#cdf315b7d90ee77a4c6ee216c3c3362da07533fd" + integrity sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg== + dependencies: + call-bind "^1.0.2" + define-properties "^1.2.0" + es-abstract "^1.22.1" + functions-have-names "^1.2.3" + functional-red-black-tree@^1.0.1, functional-red-black-tree@~1.0.1: version "1.0.1" resolved "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz" integrity sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g== -functions-have-names@^1.2.2: +functions-have-names@^1.2.2, functions-have-names@^1.2.3: version "1.2.3" resolved "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz" integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== @@ -4842,6 +5199,17 @@ get-intrinsic@^1.0.2, get-intrinsic@^1.1.1, get-intrinsic@^1.1.3, get-intrinsic@ has "^1.0.3" has-symbols "^1.0.3" +get-intrinsic@^1.2.1, get-intrinsic@^1.2.3, get-intrinsic@^1.2.4: + version "1.2.4" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.4.tgz#e385f5a4b5227d449c3eabbad05494ef0abbeadd" + integrity sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ== + dependencies: + es-errors "^1.3.0" + function-bind "^1.1.2" + has-proto "^1.0.1" + has-symbols "^1.0.3" + hasown "^2.0.0" + get-port@^3.1.0: version "3.2.0" resolved "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz" @@ -4860,6 +5228,15 @@ get-symbol-description@^1.0.0: call-bind "^1.0.2" get-intrinsic "^1.1.1" +get-symbol-description@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.2.tgz#533744d5aa20aca4e079c8e5daf7fd44202821f5" + integrity sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg== + dependencies: + call-bind "^1.0.5" + es-errors "^1.3.0" + get-intrinsic "^1.2.4" + get-value@^2.0.3, get-value@^2.0.6: version "2.0.6" resolved "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz" @@ -5082,7 +5459,7 @@ graceful-fs@4.2.10: resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz" integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== -graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.5, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.10: +graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.5, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4: version "4.2.11" resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== @@ -5227,11 +5604,23 @@ has-property-descriptors@^1.0.0: dependencies: get-intrinsic "^1.1.1" +has-property-descriptors@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854" + integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg== + dependencies: + es-define-property "^1.0.0" + has-proto@^1.0.1: version "1.0.1" resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz" integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg== +has-proto@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.0.3.tgz#b31ddfe9b0e6e9914536a6ab286426d0214f77fd" + integrity sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q== + has-symbols@^1.0.0, has-symbols@^1.0.2, has-symbols@^1.0.3: version "1.0.3" resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz" @@ -5244,6 +5633,13 @@ has-tostringtag@^1.0.0: dependencies: has-symbols "^1.0.2" +has-tostringtag@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz#2cdc42d40bef2e5b4eeab7c01a73c54ce7ab5abc" + integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== + dependencies: + has-symbols "^1.0.3" + has-value@^0.3.1: version "0.3.1" resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz" @@ -5307,6 +5703,13 @@ hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7: inherits "^2.0.3" minimalistic-assert "^1.0.1" +hasown@^2.0.0, hasown@^2.0.1, hasown@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== + dependencies: + function-bind "^1.1.2" + he@1.2.0: version "1.2.0" resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz" @@ -5408,7 +5811,7 @@ iconv-lite@0.4.24, iconv-lite@^0.4.24: dependencies: safer-buffer ">= 2.1.2 < 3" -ieee754@^1.1.13, ieee754@^1.2.1: +ieee754@^1.1.13, ieee754@^1.1.4, ieee754@^1.2.1: version "1.2.1" resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz" integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== @@ -5504,6 +5907,15 @@ internal-slot@^1.0.5: has "^1.0.3" side-channel "^1.0.4" +internal-slot@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.7.tgz#c06dcca3ed874249881007b0a5523b172a190802" + integrity sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g== + dependencies: + es-errors "^1.3.0" + hasown "^2.0.0" + side-channel "^1.0.4" + interpret@^1.0.0: version "1.4.0" resolved "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz" @@ -5539,6 +5951,14 @@ is-array-buffer@^3.0.1, is-array-buffer@^3.0.2: get-intrinsic "^1.2.0" is-typed-array "^1.1.10" +is-array-buffer@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/is-array-buffer/-/is-array-buffer-3.0.4.tgz#7a1f92b3d61edd2bc65d24f130530ea93d7fae98" + integrity sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.2.1" + is-arrayish@^0.2.1: version "0.2.1" resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz" @@ -5623,6 +6043,13 @@ is-data-descriptor@^1.0.0: dependencies: kind-of "^6.0.0" +is-data-view@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/is-data-view/-/is-data-view-1.0.1.tgz#4b4d3a511b70f3dc26d42c03ca9ca515d847759f" + integrity sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w== + dependencies: + is-typed-array "^1.1.13" + is-date-object@^1.0.1: version "1.0.5" resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz" @@ -5721,6 +6148,11 @@ is-negative-zero@^2.0.2: resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz" integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA== +is-negative-zero@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.3.tgz#ced903a027aca6381b777a5743069d7376a49747" + integrity sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw== + is-number-object@^1.0.4: version "1.0.7" resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz" @@ -5809,6 +6241,13 @@ is-shared-array-buffer@^1.0.2: dependencies: call-bind "^1.0.2" +is-shared-array-buffer@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz#1237f1cba059cdb62431d378dcc37d9680181688" + integrity sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg== + dependencies: + call-bind "^1.0.7" + is-string@^1.0.5, is-string@^1.0.7: version "1.0.7" resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz" @@ -5841,6 +6280,13 @@ is-typed-array@^1.1.10, is-typed-array@^1.1.9: gopd "^1.0.1" has-tostringtag "^1.0.0" +is-typed-array@^1.1.13: + version "1.1.13" + resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.13.tgz#d6c5ca56df62334959322d7d7dd1cca50debe229" + integrity sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw== + dependencies: + which-typed-array "^1.1.14" + is-typedarray@~1.0.0: version "1.0.0" resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz" @@ -5868,11 +6314,16 @@ is-windows@^1.0.0, is-windows@^1.0.2: resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz" integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA== -isarray@1.0.0, isarray@~1.0.0: +isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz" integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== +isarray@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.5.tgz#8af1e4c1221244cc62459faf38940d4e644a5723" + integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw== + isexe@^2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz" @@ -5890,11 +6341,24 @@ isobject@^3.0.0, isobject@^3.0.1: resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz" integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg== +isomorphic-unfetch@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/isomorphic-unfetch/-/isomorphic-unfetch-3.1.0.tgz#87341d5f4f7b63843d468438128cb087b7c3e98f" + integrity sha512-geDJjpoZ8N0kWexiwkX8F9NkTsXhetLPVbZFQ+JTW239QNOwvB0gniuR1Wc6f0AMTn7/mFGyXvHTifrCp/GH8Q== + dependencies: + node-fetch "^2.6.1" + unfetch "^4.2.0" + isstream@~0.1.2: version "0.1.2" resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz" integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g== +js-cookie@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/js-cookie/-/js-cookie-2.2.1.tgz#69e106dc5d5806894562902aa5baec3744e9b2b8" + integrity sha512-HvdH2LzI/EAZcUwA8+0nKNtWHqS+ZmijLA30RwZA0bo7ToCckjK5MkGhjED9KoRcXO6BaGI3I9UIzSA1FKFPOQ== + js-sdsl@^4.1.4: version "4.4.0" resolved "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz" @@ -6641,7 +7105,7 @@ minimist-options@4.1.0, minimist-options@^4.0.2: is-plain-obj "^1.1.0" kind-of "^6.0.3" -minimist@^1.1.0, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6: +minimist@^1.1.0, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@^1.2.7: version "1.2.8" resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz" integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== @@ -6874,6 +7338,13 @@ node-environment-flags@1.0.6: object.getownpropertydescriptors "^2.0.3" semver "^5.7.0" +node-fetch@^2.6.0, node-fetch@^2.6.1: + version "2.7.0" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d" + integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== + dependencies: + whatwg-url "^5.0.0" + node-fetch@^2.6.7: version "2.6.9" resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz" @@ -6977,6 +7448,11 @@ object-inspect@^1.12.3, object-inspect@^1.9.0: resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz" integrity sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g== +object-inspect@^1.13.1: + version "1.13.1" + resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.1.tgz#b96c6109324ccfef6b12216a956ca4dc2ff94bc2" + integrity sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ== + object-keys@^1.0.11, object-keys@^1.1.1: version "1.1.1" resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz" @@ -7009,6 +7485,16 @@ object.assign@^4.1.4: has-symbols "^1.0.3" object-keys "^1.1.1" +object.assign@^4.1.5: + version "4.1.5" + resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.5.tgz#3a833f9ab7fdb80fc9e8d2300c803d216d8fdbb0" + integrity sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ== + dependencies: + call-bind "^1.0.5" + define-properties "^1.2.1" + has-symbols "^1.0.3" + object-keys "^1.1.1" + object.getownpropertydescriptors@^2.0.3: version "2.1.5" resolved "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.5.tgz" @@ -7341,6 +7827,11 @@ posix-character-classes@^0.1.0: resolved "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz" integrity sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg== +possible-typed-array-names@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz#89bb63c6fada2c3e90adc4a647beeeb39cc7bf8f" + integrity sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q== + preferred-pm@^3.0.0: version "3.0.3" resolved "https://registry.npmjs.org/preferred-pm/-/preferred-pm-3.0.3.tgz" @@ -7390,6 +7881,15 @@ promise@^8.0.0: dependencies: asap "~2.0.6" +proper-lockfile@^4.1.1: + version "4.1.2" + resolved "https://registry.yarnpkg.com/proper-lockfile/-/proper-lockfile-4.1.2.tgz#c8b9de2af6b2f1601067f98e01ac66baa223141f" + integrity sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== + dependencies: + graceful-fs "^4.2.4" + retry "^0.12.0" + signal-exit "^3.0.2" + proto-list@~1.2.1: version "1.2.4" resolved "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz" @@ -7655,6 +8155,16 @@ regexp.prototype.flags@^1.4.3: define-properties "^1.1.3" functions-have-names "^1.2.2" +regexp.prototype.flags@^1.5.2: + version "1.5.2" + resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz#138f644a3350f981a858c44f6bb1a61ff59be334" + integrity sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw== + dependencies: + call-bind "^1.0.6" + define-properties "^1.2.1" + es-errors "^1.3.0" + set-function-name "^2.0.1" + regexpp@^3.0.0: version "3.2.0" resolved "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz" @@ -7840,6 +8350,16 @@ ret@~0.1.10: resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz" integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== +retry@0.13.1: + version "0.13.1" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz#185b1587acf67919d63b357349e03537b2484658" + integrity sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg== + +retry@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b" + integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow== + reusify@^1.0.4: version "1.0.4" resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz" @@ -7912,6 +8432,16 @@ rxjs@^7.2.0, rxjs@^7.5.5: dependencies: tslib "^2.1.0" +safe-array-concat@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/safe-array-concat/-/safe-array-concat-1.1.2.tgz#81d77ee0c4e8b863635227c721278dd524c20edb" + integrity sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q== + dependencies: + call-bind "^1.0.7" + get-intrinsic "^1.2.4" + has-symbols "^1.0.3" + isarray "^2.0.5" + safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0: version "5.2.1" resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz" @@ -7931,6 +8461,15 @@ safe-regex-test@^1.0.0: get-intrinsic "^1.1.3" is-regex "^1.1.4" +safe-regex-test@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/safe-regex-test/-/safe-regex-test-1.0.3.tgz#a5b4c0f06e0ab50ea2c395c14d8371232924c377" + integrity sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-regex "^1.1.4" + safe-regex@^1.1.0: version "1.1.0" resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz" @@ -8040,6 +8579,28 @@ set-blocking@^2.0.0: resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz" integrity sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw== +set-function-length@^1.2.1: + version "1.2.2" + resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.2.tgz#aac72314198eaed975cf77b2c3b6b880695e5449" + integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg== + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + function-bind "^1.1.2" + get-intrinsic "^1.2.4" + gopd "^1.0.1" + has-property-descriptors "^1.0.2" + +set-function-name@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/set-function-name/-/set-function-name-2.0.2.tgz#16a705c5a0dc2f5e638ca96d8a8cd4e1c2b90985" + integrity sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ== + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + functions-have-names "^1.2.3" + has-property-descriptors "^1.0.2" + set-value@^2.0.0, set-value@^2.0.1: version "2.0.1" resolved "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz" @@ -8248,6 +8809,13 @@ solhint@^5.0.1: optionalDependencies: prettier "^2.8.3" +solidity-ast@^0.4.51: + version "0.4.56" + resolved "https://registry.yarnpkg.com/solidity-ast/-/solidity-ast-0.4.56.tgz#94fe296f12e8de1a3bed319bc06db8d05a113d7a" + integrity sha512-HgmsA/Gfklm/M8GFbCX/J1qkVH0spXHgALCNZ8fA8x5X+MFdn/8CP2gr5OVyXjXw6RZTPC/Sxl2RUDQOXyNMeA== + dependencies: + array.prototype.findlast "^1.2.2" + solidity-coverage@^0.8.2: version "0.8.2" resolved "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.8.2.tgz" @@ -8453,6 +9021,16 @@ string.prototype.trim@^1.2.7: define-properties "^1.1.4" es-abstract "^1.20.4" +string.prototype.trim@^1.2.9: + version "1.2.9" + resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz#b6fa326d72d2c78b6df02f7759c73f8f6274faa4" + integrity sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.0" + es-object-atoms "^1.0.0" + string.prototype.trimend@^1.0.6: version "1.0.6" resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz" @@ -8462,6 +9040,15 @@ string.prototype.trimend@^1.0.6: define-properties "^1.1.4" es-abstract "^1.20.4" +string.prototype.trimend@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz#3651b8513719e8a9f48de7f2f77640b26652b229" + integrity sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + string.prototype.trimstart@^1.0.6: version "1.0.6" resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz" @@ -8471,6 +9058,15 @@ string.prototype.trimstart@^1.0.6: define-properties "^1.1.4" es-abstract "^1.20.4" +string.prototype.trimstart@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz#7ee834dda8c7c17eff3118472bb35bfedaa34dde" + integrity sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + string_decoder@^1.1.1: version "1.3.0" resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz" @@ -8793,7 +9389,7 @@ tsconfig-paths@^3.14.1, tsconfig-paths@^3.5.0: minimist "^1.2.6" strip-bom "^3.0.0" -tslib@^1.8.1, tslib@^1.9.3: +tslib@^1.11.1, tslib@^1.8.1, tslib@^1.9.3: version "1.14.1" resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz" integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== @@ -8803,6 +9399,11 @@ tslib@^2.1.0: resolved "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz" integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg== +tslib@^2.3.1, tslib@^2.6.2: + version "2.6.3" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.3.tgz#0438f810ad7a9edcde7a241c3d80db693c8cbfe0" + integrity sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ== + tsort@0.0.1: version "0.0.1" resolved "https://registry.npmjs.org/tsort/-/tsort-0.0.1.tgz" @@ -8920,6 +9521,38 @@ typechain@^8.0.0, typechain@^8.1.0: ts-command-line-args "^2.2.0" ts-essentials "^7.0.1" +typed-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz#1867c5d83b20fcb5ccf32649e5e2fc7424474ff3" + integrity sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ== + dependencies: + call-bind "^1.0.7" + es-errors "^1.3.0" + is-typed-array "^1.1.13" + +typed-array-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz#d92972d3cff99a3fa2e765a28fcdc0f1d89dec67" + integrity sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw== + dependencies: + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + +typed-array-byte-offset@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/typed-array-byte-offset/-/typed-array-byte-offset-1.0.2.tgz#f9ec1acb9259f395093e4567eb3c28a580d02063" + integrity sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + typed-array-length@^1.0.4: version "1.0.4" resolved "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz" @@ -8929,6 +9562,18 @@ typed-array-length@^1.0.4: for-each "^0.3.3" is-typed-array "^1.1.9" +typed-array-length@^1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/typed-array-length/-/typed-array-length-1.0.6.tgz#57155207c76e64a3457482dfdc1c9d1d3c4c73a3" + integrity sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g== + dependencies: + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + possible-typed-array-names "^1.0.0" + typedarray@^0.0.6: version "0.0.6" resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz" @@ -8971,6 +9616,11 @@ undici@^5.14.0: dependencies: busboy "^1.6.0" +unfetch@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/unfetch/-/unfetch-4.2.0.tgz#7e21b0ef7d363d8d9af0fb929a5555f6ef97a3be" + integrity sha512-F9p7yYCn6cIW9El1zi0HI6vqpeIvBsr3dSuRO6Xuppb1u5rXpCPmMvLSyECLhybr9isec8Ohl0hPekMVrEinDA== + union-value@^1.0.0: version "1.0.1" resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz" @@ -9013,7 +9663,7 @@ unset-value@^1.0.0: has-value "^0.3.1" isobject "^3.0.0" -uri-js@^4.2.2: +uri-js@^4.2.2, uri-js@^4.4.1: version "4.4.1" resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz" integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== @@ -9154,6 +9804,17 @@ which-pm@2.0.0: load-yaml-file "^0.2.0" path-exists "^4.0.0" +which-typed-array@^1.1.14, which-typed-array@^1.1.15: + version "1.1.15" + resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.15.tgz#264859e9b11a649b388bfaaf4f767df1f779b38d" + integrity sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-tostringtag "^1.0.2" + which-typed-array@^1.1.9: version "1.1.9" resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz" From cb0ca6cf9a9ec31df732b98f50a725d000cdf12a Mon Sep 17 00:00:00 2001 From: lumtis Date: Thu, 27 Jun 2024 13:24:10 +0200 Subject: [PATCH 19/86] fix yarn.lock --- yarn.lock | 10093 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 10093 insertions(+) create mode 100644 yarn.lock diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 00000000..31ffe0c1 --- /dev/null +++ b/yarn.lock @@ -0,0 +1,10093 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@aws-crypto/sha256-js@1.2.2": + version "1.2.2" + resolved "https://registry.yarnpkg.com/@aws-crypto/sha256-js/-/sha256-js-1.2.2.tgz#02acd1a1fda92896fc5a28ec7c6e164644ea32fc" + integrity sha512-Nr1QJIbW/afYYGzYvrF70LtaHrIRtd4TNAglX8BvlfxJLZ45SAmueIKYl5tWoNBPzp65ymXGFK0Bb1vZUpuc9g== + dependencies: + "@aws-crypto/util" "^1.2.2" + "@aws-sdk/types" "^3.1.0" + tslib "^1.11.1" + +"@aws-crypto/util@^1.2.2": + version "1.2.2" + resolved "https://registry.yarnpkg.com/@aws-crypto/util/-/util-1.2.2.tgz#b28f7897730eb6538b21c18bd4de22d0ea09003c" + integrity sha512-H8PjG5WJ4wz0UXAFXeJjWCW1vkvIJ3qUUD+rGRwJ2/hj+xT58Qle2MTql/2MGzkU+1JLAFuR6aJpLAjHwhmwwg== + dependencies: + "@aws-sdk/types" "^3.1.0" + "@aws-sdk/util-utf8-browser" "^3.0.0" + tslib "^1.11.1" + +"@aws-sdk/types@^3.1.0": + version "3.598.0" + resolved "https://registry.yarnpkg.com/@aws-sdk/types/-/types-3.598.0.tgz#b840d2446dee19a2a4731e6166f2327915d846db" + integrity sha512-742uRl6z7u0LFmZwDrFP6r1wlZcgVPw+/TilluDJmCAR8BgRw3IR+743kUXKBGd8QZDRW2n6v/PYsi/AWCDDMQ== + dependencies: + "@smithy/types" "^3.1.0" + tslib "^2.6.2" + +"@aws-sdk/util-utf8-browser@^3.0.0": + version "3.259.0" + resolved "https://registry.yarnpkg.com/@aws-sdk/util-utf8-browser/-/util-utf8-browser-3.259.0.tgz#3275a6f5eb334f96ca76635b961d3c50259fd9ff" + integrity sha512-UvFa/vR+e19XookZF8RzFZBrw2EUkQWxiBW0yYQAhvk3C+QVGl0H3ouca8LDBlBfQKXwmW3huo/59H8rwb1wJw== + dependencies: + tslib "^2.3.1" + +"@babel/code-frame@^7.0.0": + version "7.21.4" + resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.21.4.tgz" + integrity sha512-LYvhNKfwWSPpocw8GI7gpK2nq3HSDuEPC/uSYaALSJu9xjsalaaYFOq0Pwt5KmVqwEbZlDu81aLXwBOmD/Fv9g== + dependencies: + "@babel/highlight" "^7.18.6" + +"@babel/helper-validator-identifier@^7.18.6": + version "7.19.1" + resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz" + integrity sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w== + +"@babel/highlight@^7.18.6": + version "7.18.6" + resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz" + integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g== + dependencies: + "@babel/helper-validator-identifier" "^7.18.6" + chalk "^2.0.0" + js-tokens "^4.0.0" + +"@babel/runtime@^7.20.1", "@babel/runtime@^7.5.5": + version "7.21.0" + resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.21.0.tgz" + integrity sha512-xwII0//EObnq89Ji5AKYQaRYiW/nZ3llSv29d49IuxPhKbtJoLP+9QUUZ4nVragQVtaVGeZrpB+ZtG/Pdy/POw== + dependencies: + regenerator-runtime "^0.13.11" + +"@chainsafe/as-sha256@^0.3.1": + version "0.3.1" + resolved "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-0.3.1.tgz" + integrity sha512-hldFFYuf49ed7DAakWVXSJODuq3pzJEguD8tQ7h+sGkM18vja+OFoJI9krnGmgzyuZC2ETX0NOIcCTy31v2Mtg== + +"@chainsafe/persistent-merkle-tree@^0.4.2": + version "0.4.2" + resolved "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.4.2.tgz" + integrity sha512-lLO3ihKPngXLTus/L7WHKaw9PnNJWizlOF1H9NNzHP6Xvh82vzg9F2bzkXhYIFshMZ2gTCEz8tq6STe7r5NDfQ== + dependencies: + "@chainsafe/as-sha256" "^0.3.1" + +"@chainsafe/persistent-merkle-tree@^0.5.0": + version "0.5.0" + resolved "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.5.0.tgz" + integrity sha512-l0V1b5clxA3iwQLXP40zYjyZYospQLZXzBVIhhr9kDg/1qHZfzzHw0jj4VPBijfYCArZDlPkRi1wZaV2POKeuw== + dependencies: + "@chainsafe/as-sha256" "^0.3.1" + +"@chainsafe/ssz@^0.10.0": + version "0.10.2" + resolved "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.10.2.tgz" + integrity sha512-/NL3Lh8K+0q7A3LsiFq09YXS9fPE+ead2rr7vM2QK8PLzrNsw3uqrif9bpRX5UxgeRjM+vYi+boCM3+GM4ovXg== + dependencies: + "@chainsafe/as-sha256" "^0.3.1" + "@chainsafe/persistent-merkle-tree" "^0.5.0" + +"@chainsafe/ssz@^0.9.2": + version "0.9.4" + resolved "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.9.4.tgz" + integrity sha512-77Qtg2N1ayqs4Bg/wvnWfg5Bta7iy7IRh8XqXh7oNMeP2HBbBwx8m6yTpA8p0EHItWPEBkgZd5S5/LSlp3GXuQ== + dependencies: + "@chainsafe/as-sha256" "^0.3.1" + "@chainsafe/persistent-merkle-tree" "^0.4.2" + case "^1.6.3" + +"@changesets/apply-release-plan@^6.1.3": + version "6.1.3" + resolved "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-6.1.3.tgz" + integrity sha512-ECDNeoc3nfeAe1jqJb5aFQX7CqzQhD2klXRez2JDb/aVpGUbX673HgKrnrgJRuQR/9f2TtLoYIzrGB9qwD77mg== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/config" "^2.3.0" + "@changesets/get-version-range-type" "^0.3.2" + "@changesets/git" "^2.0.0" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + detect-indent "^6.0.0" + fs-extra "^7.0.1" + lodash.startcase "^4.4.0" + outdent "^0.5.0" + prettier "^2.7.1" + resolve-from "^5.0.0" + semver "^5.4.1" + +"@changesets/assemble-release-plan@^5.2.3": + version "5.2.3" + resolved "https://registry.npmjs.org/@changesets/assemble-release-plan/-/assemble-release-plan-5.2.3.tgz" + integrity sha512-g7EVZCmnWz3zMBAdrcKhid4hkHT+Ft1n0mLussFMcB1dE2zCuwcvGoy9ec3yOgPGF4hoMtgHaMIk3T3TBdvU9g== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/errors" "^0.1.4" + "@changesets/get-dependents-graph" "^1.3.5" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + semver "^5.4.1" + +"@changesets/changelog-git@^0.1.14": + version "0.1.14" + resolved "https://registry.npmjs.org/@changesets/changelog-git/-/changelog-git-0.1.14.tgz" + integrity sha512-+vRfnKtXVWsDDxGctOfzJsPhaCdXRYoe+KyWYoq5X/GqoISREiat0l3L8B0a453B2B4dfHGcZaGyowHbp9BSaA== + dependencies: + "@changesets/types" "^5.2.1" + +"@changesets/cli@^2.23.1": + version "2.26.1" + resolved "https://registry.npmjs.org/@changesets/cli/-/cli-2.26.1.tgz" + integrity sha512-XnTa+b51vt057fyAudvDKGB0Sh72xutQZNAdXkCqPBKO2zvs2yYZx5hFZj1u9cbtpwM6Sxtcr02/FQJfZOzemQ== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/apply-release-plan" "^6.1.3" + "@changesets/assemble-release-plan" "^5.2.3" + "@changesets/changelog-git" "^0.1.14" + "@changesets/config" "^2.3.0" + "@changesets/errors" "^0.1.4" + "@changesets/get-dependents-graph" "^1.3.5" + "@changesets/get-release-plan" "^3.0.16" + "@changesets/git" "^2.0.0" + "@changesets/logger" "^0.0.5" + "@changesets/pre" "^1.0.14" + "@changesets/read" "^0.5.9" + "@changesets/types" "^5.2.1" + "@changesets/write" "^0.2.3" + "@manypkg/get-packages" "^1.1.3" + "@types/is-ci" "^3.0.0" + "@types/semver" "^6.0.0" + ansi-colors "^4.1.3" + chalk "^2.1.0" + enquirer "^2.3.0" + external-editor "^3.1.0" + fs-extra "^7.0.1" + human-id "^1.0.2" + is-ci "^3.0.1" + meow "^6.0.0" + outdent "^0.5.0" + p-limit "^2.2.0" + preferred-pm "^3.0.0" + resolve-from "^5.0.0" + semver "^5.4.1" + spawndamnit "^2.0.0" + term-size "^2.1.0" + tty-table "^4.1.5" + +"@changesets/config@^2.3.0": + version "2.3.0" + resolved "https://registry.npmjs.org/@changesets/config/-/config-2.3.0.tgz" + integrity sha512-EgP/px6mhCx8QeaMAvWtRrgyxW08k/Bx2tpGT+M84jEdX37v3VKfh4Cz1BkwrYKuMV2HZKeHOh8sHvja/HcXfQ== + dependencies: + "@changesets/errors" "^0.1.4" + "@changesets/get-dependents-graph" "^1.3.5" + "@changesets/logger" "^0.0.5" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + fs-extra "^7.0.1" + micromatch "^4.0.2" + +"@changesets/errors@^0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@changesets/errors/-/errors-0.1.4.tgz" + integrity sha512-HAcqPF7snsUJ/QzkWoKfRfXushHTu+K5KZLJWPb34s4eCZShIf8BFO3fwq6KU8+G7L5KdtN2BzQAXOSXEyiY9Q== + dependencies: + extendable-error "^0.1.5" + +"@changesets/get-dependents-graph@^1.3.5": + version "1.3.5" + resolved "https://registry.npmjs.org/@changesets/get-dependents-graph/-/get-dependents-graph-1.3.5.tgz" + integrity sha512-w1eEvnWlbVDIY8mWXqWuYE9oKhvIaBhzqzo4ITSJY9hgoqQ3RoBqwlcAzg11qHxv/b8ReDWnMrpjpKrW6m1ZTA== + dependencies: + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + chalk "^2.1.0" + fs-extra "^7.0.1" + semver "^5.4.1" + +"@changesets/get-release-plan@^3.0.16": + version "3.0.16" + resolved "https://registry.npmjs.org/@changesets/get-release-plan/-/get-release-plan-3.0.16.tgz" + integrity sha512-OpP9QILpBp1bY2YNIKFzwigKh7Qe9KizRsZomzLe6pK8IUo8onkAAVUD8+JRKSr8R7d4+JRuQrfSSNlEwKyPYg== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/assemble-release-plan" "^5.2.3" + "@changesets/config" "^2.3.0" + "@changesets/pre" "^1.0.14" + "@changesets/read" "^0.5.9" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + +"@changesets/get-version-range-type@^0.3.2": + version "0.3.2" + resolved "https://registry.npmjs.org/@changesets/get-version-range-type/-/get-version-range-type-0.3.2.tgz" + integrity sha512-SVqwYs5pULYjYT4op21F2pVbcrca4qA/bAA3FmFXKMN7Y+HcO8sbZUTx3TAy2VXulP2FACd1aC7f2nTuqSPbqg== + +"@changesets/git@^2.0.0": + version "2.0.0" + resolved "https://registry.npmjs.org/@changesets/git/-/git-2.0.0.tgz" + integrity sha512-enUVEWbiqUTxqSnmesyJGWfzd51PY4H7mH9yUw0hPVpZBJ6tQZFMU3F3mT/t9OJ/GjyiM4770i+sehAn6ymx6A== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/errors" "^0.1.4" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + is-subdir "^1.1.1" + micromatch "^4.0.2" + spawndamnit "^2.0.0" + +"@changesets/logger@^0.0.5": + version "0.0.5" + resolved "https://registry.npmjs.org/@changesets/logger/-/logger-0.0.5.tgz" + integrity sha512-gJyZHomu8nASHpaANzc6bkQMO9gU/ib20lqew1rVx753FOxffnCrJlGIeQVxNWCqM+o6OOleCo/ivL8UAO5iFw== + dependencies: + chalk "^2.1.0" + +"@changesets/parse@^0.3.16": + version "0.3.16" + resolved "https://registry.npmjs.org/@changesets/parse/-/parse-0.3.16.tgz" + integrity sha512-127JKNd167ayAuBjUggZBkmDS5fIKsthnr9jr6bdnuUljroiERW7FBTDNnNVyJ4l69PzR57pk6mXQdtJyBCJKg== + dependencies: + "@changesets/types" "^5.2.1" + js-yaml "^3.13.1" + +"@changesets/pre@^1.0.14": + version "1.0.14" + resolved "https://registry.npmjs.org/@changesets/pre/-/pre-1.0.14.tgz" + integrity sha512-dTsHmxQWEQekHYHbg+M1mDVYFvegDh9j/kySNuDKdylwfMEevTeDouR7IfHNyVodxZXu17sXoJuf2D0vi55FHQ== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/errors" "^0.1.4" + "@changesets/types" "^5.2.1" + "@manypkg/get-packages" "^1.1.3" + fs-extra "^7.0.1" + +"@changesets/read@^0.5.9": + version "0.5.9" + resolved "https://registry.npmjs.org/@changesets/read/-/read-0.5.9.tgz" + integrity sha512-T8BJ6JS6j1gfO1HFq50kU3qawYxa4NTbI/ASNVVCBTsKquy2HYwM9r7ZnzkiMe8IEObAJtUVGSrePCOxAK2haQ== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/git" "^2.0.0" + "@changesets/logger" "^0.0.5" + "@changesets/parse" "^0.3.16" + "@changesets/types" "^5.2.1" + chalk "^2.1.0" + fs-extra "^7.0.1" + p-filter "^2.1.0" + +"@changesets/types@^4.0.1": + version "4.1.0" + resolved "https://registry.npmjs.org/@changesets/types/-/types-4.1.0.tgz" + integrity sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw== + +"@changesets/types@^5.2.1": + version "5.2.1" + resolved "https://registry.npmjs.org/@changesets/types/-/types-5.2.1.tgz" + integrity sha512-myLfHbVOqaq9UtUKqR/nZA/OY7xFjQMdfgfqeZIBK4d0hA6pgxArvdv8M+6NUzzBsjWLOtvApv8YHr4qM+Kpfg== + +"@changesets/write@^0.2.3": + version "0.2.3" + resolved "https://registry.npmjs.org/@changesets/write/-/write-0.2.3.tgz" + integrity sha512-Dbamr7AIMvslKnNYsLFafaVORx4H0pvCA2MHqgtNCySMe1blImEyAEOzDmcgKAkgz4+uwoLz7demIrX+JBr/Xw== + dependencies: + "@babel/runtime" "^7.20.1" + "@changesets/types" "^5.2.1" + fs-extra "^7.0.1" + human-id "^1.0.2" + prettier "^2.7.1" + +"@cspotcode/source-map-support@^0.8.0": + version "0.8.1" + resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz" + integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== + dependencies: + "@jridgewell/trace-mapping" "0.3.9" + +"@eslint-community/eslint-utils@^4.2.0": + version "4.4.0" + resolved "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz" + integrity sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA== + dependencies: + eslint-visitor-keys "^3.3.0" + +"@eslint-community/regexpp@^4.4.0": + version "4.5.0" + resolved "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.5.0.tgz" + integrity sha512-vITaYzIcNmjn5tF5uxcZ/ft7/RXGrMUIS9HalWckEOF6ESiwXKoMzAQf2UW0aVd6rnOeExTJVd5hmWXucBKGXQ== + +"@eslint/eslintrc@^2.0.2": + version "2.0.2" + resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.0.2.tgz" + integrity sha512-3W4f5tDUra+pA+FzgugqL2pRimUTDJWKr7BINqOpkZrC0uYI0NIc0/JFgBROCU07HR6GieA5m3/rsPIhDmCXTQ== + dependencies: + ajv "^6.12.4" + debug "^4.3.2" + espree "^9.5.1" + globals "^13.19.0" + ignore "^5.2.0" + import-fresh "^3.2.1" + js-yaml "^4.1.0" + minimatch "^3.1.2" + strip-json-comments "^3.1.1" + +"@eslint/js@8.38.0": + version "8.38.0" + resolved "https://registry.npmjs.org/@eslint/js/-/js-8.38.0.tgz" + integrity sha512-IoD2MfUnOV58ghIHCiil01PcohxjbYR/qCxsoC+xNgUwh1EY8jOOrYmu3d3a71+tJJ23uscEV4X2HJWMsPJu4g== + +"@ethereum-waffle/chai@4.0.10": + version "4.0.10" + resolved "https://registry.npmjs.org/@ethereum-waffle/chai/-/chai-4.0.10.tgz" + integrity sha512-X5RepE7Dn8KQLFO7HHAAe+KeGaX/by14hn90wePGBhzL54tq4Y8JscZFu+/LCwCl6TnkAAy5ebiMoqJ37sFtWw== + dependencies: + "@ethereum-waffle/provider" "4.0.5" + debug "^4.3.4" + json-bigint "^1.0.0" + +"@ethereum-waffle/compiler@4.0.3": + version "4.0.3" + resolved "https://registry.npmjs.org/@ethereum-waffle/compiler/-/compiler-4.0.3.tgz" + integrity sha512-5x5U52tSvEVJS6dpCeXXKvRKyf8GICDwiTwUvGD3/WD+DpvgvaoHOL82XqpTSUHgV3bBq6ma5/8gKUJUIAnJCw== + dependencies: + "@resolver-engine/imports" "^0.3.3" + "@resolver-engine/imports-fs" "^0.3.3" + "@typechain/ethers-v5" "^10.0.0" + "@types/mkdirp" "^0.5.2" + "@types/node-fetch" "^2.6.1" + mkdirp "^0.5.1" + node-fetch "^2.6.7" + +"@ethereum-waffle/ens@4.0.3": + version "4.0.3" + resolved "https://registry.npmjs.org/@ethereum-waffle/ens/-/ens-4.0.3.tgz" + integrity sha512-PVLcdnTbaTfCrfSOrvtlA9Fih73EeDvFS28JQnT5M5P4JMplqmchhcZB1yg/fCtx4cvgHlZXa0+rOCAk2Jk0Jw== + +"@ethereum-waffle/mock-contract@4.0.4": + version "4.0.4" + resolved "https://registry.npmjs.org/@ethereum-waffle/mock-contract/-/mock-contract-4.0.4.tgz" + integrity sha512-LwEj5SIuEe9/gnrXgtqIkWbk2g15imM/qcJcxpLyAkOj981tQxXmtV4XmQMZsdedEsZ/D/rbUAOtZbgwqgUwQA== + +"@ethereum-waffle/provider@4.0.5": + version "4.0.5" + resolved "https://registry.npmjs.org/@ethereum-waffle/provider/-/provider-4.0.5.tgz" + integrity sha512-40uzfyzcrPh+Gbdzv89JJTMBlZwzya1YLDyim8mVbEqYLP5VRYWoGp0JMyaizgV3hMoUFRqJKVmIUw4v7r3hYw== + dependencies: + "@ethereum-waffle/ens" "4.0.3" + "@ganache/ethereum-options" "0.1.4" + debug "^4.3.4" + ganache "7.4.3" + +"@ethereumjs/block@^3.5.0", "@ethereumjs/block@^3.6.0", "@ethereumjs/block@^3.6.2": + version "3.6.3" + resolved "https://registry.npmjs.org/@ethereumjs/block/-/block-3.6.3.tgz" + integrity sha512-CegDeryc2DVKnDkg5COQrE0bJfw/p0v3GBk2W5/Dj5dOVfEmb50Ux0GLnSPypooLnfqjwFaorGuT9FokWB3GRg== + dependencies: + "@ethereumjs/common" "^2.6.5" + "@ethereumjs/tx" "^3.5.2" + ethereumjs-util "^7.1.5" + merkle-patricia-tree "^4.2.4" + +"@ethereumjs/blockchain@^5.5.0": + version "5.5.3" + resolved "https://registry.npmjs.org/@ethereumjs/blockchain/-/blockchain-5.5.3.tgz" + integrity sha512-bi0wuNJ1gw4ByNCV56H0Z4Q7D+SxUbwyG12Wxzbvqc89PXLRNR20LBcSUZRKpN0+YCPo6m0XZL/JLio3B52LTw== + dependencies: + "@ethereumjs/block" "^3.6.2" + "@ethereumjs/common" "^2.6.4" + "@ethereumjs/ethash" "^1.1.0" + debug "^4.3.3" + ethereumjs-util "^7.1.5" + level-mem "^5.0.1" + lru-cache "^5.1.1" + semaphore-async-await "^1.5.1" + +"@ethereumjs/common@2.6.0": + version "2.6.0" + resolved "https://registry.npmjs.org/@ethereumjs/common/-/common-2.6.0.tgz" + integrity sha512-Cq2qS0FTu6O2VU1sgg+WyU9Ps0M6j/BEMHN+hRaECXCV/r0aI78u4N6p52QW/BDVhwWZpCdrvG8X7NJdzlpNUA== + dependencies: + crc-32 "^1.2.0" + ethereumjs-util "^7.1.3" + +"@ethereumjs/common@^2.6.0", "@ethereumjs/common@^2.6.4", "@ethereumjs/common@^2.6.5": + version "2.6.5" + resolved "https://registry.npmjs.org/@ethereumjs/common/-/common-2.6.5.tgz" + integrity sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA== + dependencies: + crc-32 "^1.2.0" + ethereumjs-util "^7.1.5" + +"@ethereumjs/ethash@^1.1.0": + version "1.1.0" + resolved "https://registry.npmjs.org/@ethereumjs/ethash/-/ethash-1.1.0.tgz" + integrity sha512-/U7UOKW6BzpA+Vt+kISAoeDie1vAvY4Zy2KF5JJb+So7+1yKmJeJEHOGSnQIj330e9Zyl3L5Nae6VZyh2TJnAA== + dependencies: + "@ethereumjs/block" "^3.5.0" + "@types/levelup" "^4.3.0" + buffer-xor "^2.0.1" + ethereumjs-util "^7.1.1" + miller-rabin "^4.0.0" + +"@ethereumjs/rlp@^4.0.1": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@ethereumjs/rlp/-/rlp-4.0.1.tgz#626fabfd9081baab3d0a3074b0c7ecaf674aaa41" + integrity sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw== + +"@ethereumjs/tx@3.4.0": + version "3.4.0" + resolved "https://registry.npmjs.org/@ethereumjs/tx/-/tx-3.4.0.tgz" + integrity sha512-WWUwg1PdjHKZZxPPo274ZuPsJCWV3SqATrEKQP1n2DrVYVP1aZIYpo/mFaA0BDoE0tIQmBeimRCEA0Lgil+yYw== + dependencies: + "@ethereumjs/common" "^2.6.0" + ethereumjs-util "^7.1.3" + +"@ethereumjs/tx@^3.4.0", "@ethereumjs/tx@^3.5.2": + version "3.5.2" + resolved "https://registry.npmjs.org/@ethereumjs/tx/-/tx-3.5.2.tgz" + integrity sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw== + dependencies: + "@ethereumjs/common" "^2.6.4" + ethereumjs-util "^7.1.5" + +"@ethereumjs/util@^8.1.0": + version "8.1.0" + resolved "https://registry.yarnpkg.com/@ethereumjs/util/-/util-8.1.0.tgz#299df97fb6b034e0577ce9f94c7d9d1004409ed4" + integrity sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA== + dependencies: + "@ethereumjs/rlp" "^4.0.1" + ethereum-cryptography "^2.0.0" + micro-ftch "^0.3.1" + +"@ethereumjs/vm@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethereumjs/vm/-/vm-5.6.0.tgz" + integrity sha512-J2m/OgjjiGdWF2P9bj/4LnZQ1zRoZhY8mRNVw/N3tXliGI8ai1sI1mlDPkLpeUUM4vq54gH6n0ZlSpz8U/qlYQ== + dependencies: + "@ethereumjs/block" "^3.6.0" + "@ethereumjs/blockchain" "^5.5.0" + "@ethereumjs/common" "^2.6.0" + "@ethereumjs/tx" "^3.4.0" + async-eventemitter "^0.2.4" + core-js-pure "^3.0.1" + debug "^2.2.0" + ethereumjs-util "^7.1.3" + functional-red-black-tree "^1.0.1" + mcl-wasm "^0.7.1" + merkle-patricia-tree "^4.2.2" + rustbn.js "~0.2.0" + +"@ethersproject/abi@5.6.3": + version "5.6.3" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.6.3.tgz" + integrity sha512-CxKTdoZY4zDJLWXG6HzNH6znWK0M79WzzxHegDoecE3+K32pzfHOzuXg2/oGSTecZynFgpkjYXNPOqXVJlqClw== + dependencies: + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/abi@5.7.0", "@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.0.9", "@ethersproject/abi@^5.1.2", "@ethersproject/abi@^5.4.7", "@ethersproject/abi@^5.5.0", "@ethersproject/abi@^5.6.3", "@ethersproject/abi@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz" + integrity sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA== + dependencies: + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/abstract-provider@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.6.1.tgz" + integrity sha512-BxlIgogYJtp1FS8Muvj8YfdClk3unZH0vRMVX791Z9INBNT/kuACZ9GzaY1Y4yFq+YSy6/w4gzj3HCRKrK9hsQ== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.3" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/web" "^5.6.1" + +"@ethersproject/abstract-provider@5.7.0", "@ethersproject/abstract-provider@^5.6.1", "@ethersproject/abstract-provider@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz" + integrity sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/networks" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/web" "^5.7.0" + +"@ethersproject/abstract-signer@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.6.2.tgz" + integrity sha512-n1r6lttFBG0t2vNiI3HoWaS/KdOt8xyDjzlP2cuevlWLG6EX0OwcKLyG/Kp/cuwNxdy/ous+R/DEMdTUwWQIjQ== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/abstract-signer@5.7.0", "@ethersproject/abstract-signer@^5.6.2", "@ethersproject/abstract-signer@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz" + integrity sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + +"@ethersproject/address@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.6.1.tgz" + integrity sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/rlp" "^5.6.1" + +"@ethersproject/address@5.7.0", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.6.1", "@ethersproject/address@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz" + integrity sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + +"@ethersproject/base64@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.6.1.tgz" + integrity sha512-qB76rjop6a0RIYYMiB4Eh/8n+Hxu2NIZm8S/Q7kNo5pmZfXhHGHmS4MinUainiBC54SCyRnwzL+KZjj8zbsSsw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + +"@ethersproject/base64@5.7.0", "@ethersproject/base64@^5.6.1", "@ethersproject/base64@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz" + integrity sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ== + dependencies: + "@ethersproject/bytes" "^5.7.0" + +"@ethersproject/basex@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.6.1.tgz" + integrity sha512-a52MkVz4vuBXR06nvflPMotld1FJWSj2QT0985v7P/emPZO00PucFAkbcmq2vpVU7Ts7umKiSI6SppiLykVWsA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/basex@5.7.0", "@ethersproject/basex@^5.6.1", "@ethersproject/basex@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz" + integrity sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + +"@ethersproject/bignumber@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.6.2.tgz" + integrity sha512-v7+EEUbhGqT3XJ9LMPsKvXYHFc8eHxTowFCG/HgJErmq4XHJ2WR7aeyICg3uTOAQ7Icn0GFHAohXEhxQHq4Ubw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + bn.js "^5.2.1" + +"@ethersproject/bignumber@5.7.0", "@ethersproject/bignumber@^5.6.2", "@ethersproject/bignumber@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz" + integrity sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + bn.js "^5.2.1" + +"@ethersproject/bytes@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.6.1.tgz" + integrity sha512-NwQt7cKn5+ZE4uDn+X5RAXLp46E1chXoaMmrxAyA0rblpxz8t58lVkrHXoRIn0lz1joQElQ8410GqhTqMOwc6g== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/bytes@5.7.0", "@ethersproject/bytes@^5.6.1", "@ethersproject/bytes@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz" + integrity sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/constants@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.6.1.tgz" + integrity sha512-QSq9WVnZbxXYFftrjSjZDUshp6/eKp6qrtdBtUCm0QxCV5z1fG/w3kdlcsjMCQuQHUnAclKoK7XpXMezhRDOLg== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + +"@ethersproject/constants@5.7.0", "@ethersproject/constants@^5.6.1", "@ethersproject/constants@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz" + integrity sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + +"@ethersproject/contracts@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.6.2.tgz" + integrity sha512-hguUA57BIKi6WY0kHvZp6PwPlWF87MCeB4B7Z7AbUpTxfFXFdn/3b0GmjZPagIHS+3yhcBJDnuEfU4Xz+Ks/8g== + dependencies: + "@ethersproject/abi" "^5.6.3" + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.2" + +"@ethersproject/contracts@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz" + integrity sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg== + dependencies: + "@ethersproject/abi" "^5.7.0" + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + +"@ethersproject/hash@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.6.1.tgz" + integrity sha512-L1xAHurbaxG8VVul4ankNX5HgQ8PNCTrnVXEiFnE9xoRnaUcgfD12tZINtDinSllxPLCtGwguQxJ5E6keE84pA== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/hash@5.7.0", "@ethersproject/hash@^5.6.1", "@ethersproject/hash@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz" + integrity sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/base64" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/hdnode@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.6.2.tgz" + integrity sha512-tERxW8Ccf9CxW2db3WsN01Qao3wFeRsfYY9TCuhmG0xNpl2IO8wgXU3HtWIZ49gUWPggRy4Yg5axU0ACaEKf1Q== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/basex" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/wordlists" "^5.6.1" + +"@ethersproject/hdnode@5.7.0", "@ethersproject/hdnode@^5.6.2", "@ethersproject/hdnode@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz" + integrity sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/basex" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/pbkdf2" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/wordlists" "^5.7.0" + +"@ethersproject/json-wallets@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.6.1.tgz" + integrity sha512-KfyJ6Zwz3kGeX25nLihPwZYlDqamO6pfGKNnVMWWfEVVp42lTfCZVXXy5Ie8IZTN0HKwAngpIPi7gk4IJzgmqQ== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hdnode" "^5.6.2" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + aes-js "3.0.0" + scrypt-js "3.0.1" + +"@ethersproject/json-wallets@5.7.0", "@ethersproject/json-wallets@^5.6.1", "@ethersproject/json-wallets@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz" + integrity sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hdnode" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/pbkdf2" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + aes-js "3.0.0" + scrypt-js "3.0.1" + +"@ethersproject/keccak256@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.6.1.tgz" + integrity sha512-bB7DQHCTRDooZZdL3lk9wpL0+XuG3XLGHLh3cePnybsO3V0rdCAOQGpn/0R3aODmnTOOkCATJiD2hnL+5bwthA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + js-sha3 "0.8.0" + +"@ethersproject/keccak256@5.7.0", "@ethersproject/keccak256@^5.6.1", "@ethersproject/keccak256@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz" + integrity sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg== + dependencies: + "@ethersproject/bytes" "^5.7.0" + js-sha3 "0.8.0" + +"@ethersproject/logger@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.6.0.tgz" + integrity sha512-BiBWllUROH9w+P21RzoxJKzqoqpkyM1pRnEKG69bulE9TSQD8SAIvTQqIMZmmCO8pUNkgLP1wndX1gKghSpBmg== + +"@ethersproject/logger@5.7.0", "@ethersproject/logger@^5.6.0", "@ethersproject/logger@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz" + integrity sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig== + +"@ethersproject/networks@5.6.3": + version "5.6.3" + resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.6.3.tgz" + integrity sha512-QZxRH7cA5Ut9TbXwZFiCyuPchdWi87ZtVNHWZd0R6YFgYtes2jQ3+bsslJ0WdyDe0i6QumqtoYqvY3rrQFRZOQ== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/networks@5.7.1", "@ethersproject/networks@^5.6.3", "@ethersproject/networks@^5.7.0": + version "5.7.1" + resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz" + integrity sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/pbkdf2@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.6.1.tgz" + integrity sha512-k4gRQ+D93zDRPNUfmduNKq065uadC2YjMP/CqwwX5qG6R05f47boq6pLZtV/RnC4NZAYOPH1Cyo54q0c9sshRQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/sha2" "^5.6.1" + +"@ethersproject/pbkdf2@5.7.0", "@ethersproject/pbkdf2@^5.6.1", "@ethersproject/pbkdf2@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz" + integrity sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + +"@ethersproject/properties@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.6.0.tgz" + integrity sha512-szoOkHskajKePTJSZ46uHUWWkbv7TzP2ypdEK6jGMqJaEt2sb0jCgfBo0gH0m2HBpRixMuJ6TBRaQCF7a9DoCg== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/properties@5.7.0", "@ethersproject/properties@^5.6.0", "@ethersproject/properties@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz" + integrity sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/providers@5.6.8": + version "5.6.8" + resolved "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.6.8.tgz" + integrity sha512-Wf+CseT/iOJjrGtAOf3ck9zS7AgPmr2fZ3N97r4+YXN3mBePTG2/bJ8DApl9mVwYL+RpYbNxMEkEp4mPGdwG/w== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/base64" "^5.6.1" + "@ethersproject/basex" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.3" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/rlp" "^5.6.1" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/web" "^5.6.1" + bech32 "1.1.4" + ws "7.4.6" + +"@ethersproject/providers@5.7.2", "@ethersproject/providers@^5.4.7", "@ethersproject/providers@^5.7.1", "@ethersproject/providers@^5.7.2": + version "5.7.2" + resolved "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz" + integrity sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/base64" "^5.7.0" + "@ethersproject/basex" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/networks" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/web" "^5.7.0" + bech32 "1.1.4" + ws "7.4.6" + +"@ethersproject/random@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/random/-/random-5.6.1.tgz" + integrity sha512-/wtPNHwbmng+5yi3fkipA8YBT59DdkGRoC2vWk09Dci/q5DlgnMkhIycjHlavrvrjJBkFjO/ueLyT+aUDfc4lA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/random@5.7.0", "@ethersproject/random@^5.6.1", "@ethersproject/random@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz" + integrity sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/rlp@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.6.1.tgz" + integrity sha512-uYjmcZx+DKlFUk7a5/W9aQVaoEC7+1MOBgNtvNg13+RnuUwT4F0zTovC0tmay5SmRslb29V1B7Y5KCri46WhuQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/rlp@5.7.0", "@ethersproject/rlp@^5.6.1", "@ethersproject/rlp@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz" + integrity sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/sha2@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.6.1.tgz" + integrity sha512-5K2GyqcW7G4Yo3uenHegbXRPDgARpWUiXc6RiF7b6i/HXUoWlb7uCARh7BAHg7/qT/Q5ydofNwiZcim9qpjB6g== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + hash.js "1.1.7" + +"@ethersproject/sha2@5.7.0", "@ethersproject/sha2@^5.6.1", "@ethersproject/sha2@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz" + integrity sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + hash.js "1.1.7" + +"@ethersproject/signing-key@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.6.2.tgz" + integrity sha512-jVbu0RuP7EFpw82vHcL+GP35+KaNruVAZM90GxgQnGqB6crhBqW/ozBfFvdeImtmb4qPko0uxXjn8l9jpn0cwQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + bn.js "^5.2.1" + elliptic "6.5.4" + hash.js "1.1.7" + +"@ethersproject/signing-key@5.7.0", "@ethersproject/signing-key@^5.6.2", "@ethersproject/signing-key@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz" + integrity sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + bn.js "^5.2.1" + elliptic "6.5.4" + hash.js "1.1.7" + +"@ethersproject/solidity@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.6.1.tgz" + integrity sha512-KWqVLkUUoLBfL1iwdzUVlkNqAUIFMpbbeH0rgCfKmJp0vFtY4AsaN91gHKo9ZZLkC4UOm3cI3BmMV4N53BOq4g== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/solidity@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz" + integrity sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/strings@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.6.1.tgz" + integrity sha512-2X1Lgk6Jyfg26MUnsHiT456U9ijxKUybz8IM1Vih+NJxYtXhmvKBcHOmvGqpFSVJ0nQ4ZCoIViR8XlRw1v/+Cw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/strings@5.7.0", "@ethersproject/strings@^5.6.1", "@ethersproject/strings@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz" + integrity sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/transactions@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.6.2.tgz" + integrity sha512-BuV63IRPHmJvthNkkt9G70Ullx6AcM+SDc+a8Aw/8Yew6YwT51TcBKEp1P4oOQ/bP25I18JJr7rcFRgFtU9B2Q== + dependencies: + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/rlp" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + +"@ethersproject/transactions@5.7.0", "@ethersproject/transactions@^5.6.2", "@ethersproject/transactions@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz" + integrity sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ== + dependencies: + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + +"@ethersproject/units@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/units/-/units-5.6.1.tgz" + integrity sha512-rEfSEvMQ7obcx3KWD5EWWx77gqv54K6BKiZzKxkQJqtpriVsICrktIQmKl8ReNToPeIYPnFHpXvKpi068YFZXw== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/units@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz" + integrity sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/wallet@5.6.2": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.6.2.tgz" + integrity sha512-lrgh0FDQPuOnHcF80Q3gHYsSUODp6aJLAdDmDV0xKCN/T7D99ta1jGVhulg3PY8wiXEngD0DfM0I2XKXlrqJfg== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/hdnode" "^5.6.2" + "@ethersproject/json-wallets" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/wordlists" "^5.6.1" + +"@ethersproject/wallet@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz" + integrity sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/hdnode" "^5.7.0" + "@ethersproject/json-wallets" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/wordlists" "^5.7.0" + +"@ethersproject/web@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.6.1.tgz" + integrity sha512-/vSyzaQlNXkO1WV+RneYKqCJwualcUdx/Z3gseVovZP0wIlOFcCE1hkRhKBH8ImKbGQbMl9EAAyJFrJu7V0aqA== + dependencies: + "@ethersproject/base64" "^5.6.1" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/web@5.7.1", "@ethersproject/web@^5.6.1", "@ethersproject/web@^5.7.0": + version "5.7.1" + resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz" + integrity sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w== + dependencies: + "@ethersproject/base64" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/wordlists@5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.6.1.tgz" + integrity sha512-wiPRgBpNbNwCQFoCr8bcWO8o5I810cqO6mkdtKfLKFlLxeCWcnzDi4Alu8iyNzlhYuS9npCwivMbRWF19dyblw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/wordlists@5.7.0", "@ethersproject/wordlists@^5.6.1", "@ethersproject/wordlists@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz" + integrity sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ganache/ethereum-address@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/ethereum-address/-/ethereum-address-0.1.4.tgz" + integrity sha512-sTkU0M9z2nZUzDeHRzzGlW724xhMLXo2LeX1hixbnjHWY1Zg1hkqORywVfl+g5uOO8ht8T0v+34IxNxAhmWlbw== + dependencies: + "@ganache/utils" "0.1.4" + +"@ganache/ethereum-options@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/ethereum-options/-/ethereum-options-0.1.4.tgz" + integrity sha512-i4l46taoK2yC41FPkcoDlEVoqHS52wcbHPqJtYETRWqpOaoj9hAg/EJIHLb1t6Nhva2CdTO84bG+qlzlTxjAHw== + dependencies: + "@ganache/ethereum-address" "0.1.4" + "@ganache/ethereum-utils" "0.1.4" + "@ganache/options" "0.1.4" + "@ganache/utils" "0.1.4" + bip39 "3.0.4" + seedrandom "3.0.5" + +"@ganache/ethereum-utils@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/ethereum-utils/-/ethereum-utils-0.1.4.tgz" + integrity sha512-FKXF3zcdDrIoCqovJmHLKZLrJ43234Em2sde/3urUT/10gSgnwlpFmrv2LUMAmSbX3lgZhW/aSs8krGhDevDAg== + dependencies: + "@ethereumjs/common" "2.6.0" + "@ethereumjs/tx" "3.4.0" + "@ethereumjs/vm" "5.6.0" + "@ganache/ethereum-address" "0.1.4" + "@ganache/rlp" "0.1.4" + "@ganache/utils" "0.1.4" + emittery "0.10.0" + ethereumjs-abi "0.6.8" + ethereumjs-util "7.1.3" + +"@ganache/options@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/options/-/options-0.1.4.tgz" + integrity sha512-zAe/craqNuPz512XQY33MOAG6Si1Xp0hCvfzkBfj2qkuPcbJCq6W/eQ5MB6SbXHrICsHrZOaelyqjuhSEmjXRw== + dependencies: + "@ganache/utils" "0.1.4" + bip39 "3.0.4" + seedrandom "3.0.5" + +"@ganache/rlp@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/rlp/-/rlp-0.1.4.tgz" + integrity sha512-Do3D1H6JmhikB+6rHviGqkrNywou/liVeFiKIpOBLynIpvZhRCgn3SEDxyy/JovcaozTo/BynHumfs5R085MFQ== + dependencies: + "@ganache/utils" "0.1.4" + rlp "2.2.6" + +"@ganache/utils@0.1.4": + version "0.1.4" + resolved "https://registry.npmjs.org/@ganache/utils/-/utils-0.1.4.tgz" + integrity sha512-oatUueU3XuXbUbUlkyxeLLH3LzFZ4y5aSkNbx6tjSIhVTPeh+AuBKYt4eQ73FFcTB3nj/gZoslgAh5CN7O369w== + dependencies: + emittery "0.10.0" + keccak "3.0.1" + seedrandom "3.0.5" + optionalDependencies: + "@trufflesuite/bigint-buffer" "1.1.9" + +"@humanwhocodes/config-array@^0.11.8": + version "0.11.8" + resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz" + integrity sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g== + dependencies: + "@humanwhocodes/object-schema" "^1.2.1" + debug "^4.1.1" + minimatch "^3.0.5" + +"@humanwhocodes/module-importer@^1.0.1": + version "1.0.1" + resolved "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz" + integrity sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA== + +"@humanwhocodes/object-schema@^1.2.1": + version "1.2.1" + resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz" + integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== + +"@jridgewell/resolve-uri@^3.0.3": + version "3.1.1" + resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz" + integrity sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA== + +"@jridgewell/sourcemap-codec@^1.4.10": + version "1.4.15" + resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz" + integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== + +"@jridgewell/trace-mapping@0.3.9": + version "0.3.9" + resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz" + integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== + dependencies: + "@jridgewell/resolve-uri" "^3.0.3" + "@jridgewell/sourcemap-codec" "^1.4.10" + +"@manypkg/find-root@^1.1.0": + version "1.1.0" + resolved "https://registry.npmjs.org/@manypkg/find-root/-/find-root-1.1.0.tgz" + integrity sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA== + dependencies: + "@babel/runtime" "^7.5.5" + "@types/node" "^12.7.1" + find-up "^4.1.0" + fs-extra "^8.1.0" + +"@manypkg/get-packages@^1.1.3": + version "1.1.3" + resolved "https://registry.npmjs.org/@manypkg/get-packages/-/get-packages-1.1.3.tgz" + integrity sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A== + dependencies: + "@babel/runtime" "^7.5.5" + "@changesets/types" "^4.0.1" + "@manypkg/find-root" "^1.1.0" + fs-extra "^8.1.0" + globby "^11.0.0" + read-yaml-file "^1.1.0" + +"@metamask/eth-sig-util@^4.0.0": + version "4.0.1" + resolved "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz" + integrity sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ== + dependencies: + ethereumjs-abi "^0.6.8" + ethereumjs-util "^6.2.1" + ethjs-util "^0.1.6" + tweetnacl "^1.0.3" + tweetnacl-util "^0.15.1" + +"@morgan-stanley/ts-mocking-bird@^0.6.2": + version "0.6.4" + resolved "https://registry.npmjs.org/@morgan-stanley/ts-mocking-bird/-/ts-mocking-bird-0.6.4.tgz" + integrity sha512-57VJIflP8eR2xXa9cD1LUawh+Gh+BVQfVu0n6GALyg/AqV/Nz25kDRvws3i9kIe1PTrbsZZOYpsYp6bXPd6nVA== + dependencies: + lodash "^4.17.16" + uuid "^7.0.3" + +"@noble/curves@1.4.0", "@noble/curves@~1.4.0": + version "1.4.0" + resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-1.4.0.tgz#f05771ef64da724997f69ee1261b2417a49522d6" + integrity sha512-p+4cb332SFCrReJkCYe8Xzm0OWi4Jji5jVdIZRL/PmacmDkFNw6MrrV+gGpiPxLHbV+zKFRywUWbaseT+tZRXg== + dependencies: + "@noble/hashes" "1.4.0" + +"@noble/hashes@1.2.0", "@noble/hashes@~1.2.0": + version "1.2.0" + resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.2.0.tgz" + integrity sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ== + +"@noble/hashes@1.4.0", "@noble/hashes@~1.4.0": + version "1.4.0" + resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.4.0.tgz#45814aa329f30e4fe0ba49426f49dfccdd066426" + integrity sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg== + +"@noble/secp256k1@1.7.1", "@noble/secp256k1@~1.7.0": + version "1.7.1" + resolved "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz" + integrity sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw== + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3", "@nodelib/fs.walk@^1.2.8": + version "1.2.8" + resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@nomicfoundation/ethereumjs-block@5.0.0": + version "5.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-5.0.0.tgz" + integrity sha512-DfhVbqM5DjriguuSv6r3TgOpyXC76oX8D/VEODsSwJQ1bZGqu4xLLfYPPTacpCAYOnewzJsZli+Ao9TBTAo2uw== + dependencies: + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-trie" "6.0.0" + "@nomicfoundation/ethereumjs-tx" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + ethereum-cryptography "0.1.3" + ethers "^5.7.1" + +"@nomicfoundation/ethereumjs-blockchain@7.0.0": + version "7.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-7.0.0.tgz" + integrity sha512-cVRCrXZminZr0Mbx2hm0/109GZLn1v5bf0/k+SIbGn50yZm6YCdQt9CgGT0Gk56N2vy8NhXD4apo167m4LWk6Q== + dependencies: + "@nomicfoundation/ethereumjs-block" "5.0.0" + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-ethash" "3.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-trie" "6.0.0" + "@nomicfoundation/ethereumjs-tx" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + abstract-level "^1.0.3" + debug "^4.3.3" + ethereum-cryptography "0.1.3" + level "^8.0.0" + lru-cache "^5.1.1" + memory-level "^1.0.0" + +"@nomicfoundation/ethereumjs-common@4.0.0": + version "4.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-4.0.0.tgz" + integrity sha512-UPpm5FAGAf2B6hQ8aVgO44Rdo0k73oMMCViqNJcKMlk1s9l3rxwuPTp1l20NiGvNO2Pzqk3chFL+BzmLL2g4wQ== + dependencies: + "@nomicfoundation/ethereumjs-util" "9.0.0" + crc-32 "^1.2.0" + +"@nomicfoundation/ethereumjs-ethash@3.0.0": + version "3.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-3.0.0.tgz" + integrity sha512-6zNv5Y3vNIsxjrsbKjMInVpo8cmR0c7yjZbBpy7NYuIMtm0JKhQoXsiFN56t/1sfn9V3v0wgrkAixo5v6bahpA== + dependencies: + "@nomicfoundation/ethereumjs-block" "5.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + abstract-level "^1.0.3" + bigint-crypto-utils "^3.0.23" + ethereum-cryptography "0.1.3" + +"@nomicfoundation/ethereumjs-evm@2.0.0": + version "2.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-2.0.0.tgz" + integrity sha512-D+tr3M9sictopr3E20OVgme7YF/d0fU566WKh+ofXwmxapz/Dd8RSLSaVeKgfCI2BkzVA+XqXY08NNCV8w8fWA== + dependencies: + "@ethersproject/providers" "^5.7.1" + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-tx" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + debug "^4.3.3" + ethereum-cryptography "0.1.3" + mcl-wasm "^0.7.1" + rustbn.js "~0.2.0" + +"@nomicfoundation/ethereumjs-rlp@5.0.0": + version "5.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-5.0.0.tgz" + integrity sha512-U1A0y330PtGb8Wft4yPVv0myWYJTesi89ItGoB0ICdqz7793KmUhpfQb2vJUXBi98wSdnxkIABO/GmsQvGKVDw== + +"@nomicfoundation/ethereumjs-statemanager@2.0.0": + version "2.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-2.0.0.tgz" + integrity sha512-tgXtsx8yIDlxWMN+ThqPtGK0ITAuITrDy+GYIgGrnT6ZtelvXWM7SUYR0Mcv578lmGCoIwyHFtSBqOkOBYHLjw== + dependencies: + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + debug "^4.3.3" + ethereum-cryptography "0.1.3" + ethers "^5.7.1" + js-sdsl "^4.1.4" + +"@nomicfoundation/ethereumjs-trie@6.0.0": + version "6.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-6.0.0.tgz" + integrity sha512-YqPWiNxrZvL+Ef7KHqgru1IlaIGXhu78wd2fxNFOvi/NAQBF845dVfTKKXs1L9x0QBRRQRephgxHCKMuISGppw== + dependencies: + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + "@types/readable-stream" "^2.3.13" + ethereum-cryptography "0.1.3" + readable-stream "^3.6.0" + +"@nomicfoundation/ethereumjs-tx@5.0.0": + version "5.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-5.0.0.tgz" + integrity sha512-LTyxI+zBJ+HuEBblUGbxvfKl1hg1uJlz2XhnszNagiBWQSgLb1vQCa1QaXV5Q8cUDYkr/Xe4NXWiUGEvH4e6lA== + dependencies: + "@chainsafe/ssz" "^0.9.2" + "@ethersproject/providers" "^5.7.2" + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + ethereum-cryptography "0.1.3" + +"@nomicfoundation/ethereumjs-util@9.0.0": + version "9.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-9.0.0.tgz" + integrity sha512-9EG98CsEC9BnI7AY27F4QXZ8Vf0re8R9XoxQ0//KWF+B7quu6GQvgTq1RlNUjGh/XNCCJNf8E3LOY9ULR85wFQ== + dependencies: + "@chainsafe/ssz" "^0.10.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + ethereum-cryptography "0.1.3" + +"@nomicfoundation/ethereumjs-vm@7.0.0": + version "7.0.0" + resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-7.0.0.tgz" + integrity sha512-eHkEoe/4r4+g+fZyIIlQjBHEjCPFs8CHiIEEMvMfvFrV4hyHnuTg4LH7l92ok7TGZqpWxgMG2JOEUFkNsXrKuQ== + dependencies: + "@nomicfoundation/ethereumjs-block" "5.0.0" + "@nomicfoundation/ethereumjs-blockchain" "7.0.0" + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-evm" "2.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-statemanager" "2.0.0" + "@nomicfoundation/ethereumjs-trie" "6.0.0" + "@nomicfoundation/ethereumjs-tx" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + debug "^4.3.3" + ethereum-cryptography "0.1.3" + mcl-wasm "^0.7.1" + rustbn.js "~0.2.0" + +"@nomicfoundation/hardhat-chai-matchers@^1.0.6": + version "1.0.6" + resolved "https://registry.npmjs.org/@nomicfoundation/hardhat-chai-matchers/-/hardhat-chai-matchers-1.0.6.tgz" + integrity sha512-f5ZMNmabZeZegEfuxn/0kW+mm7+yV7VNDxLpMOMGXWFJ2l/Ct3QShujzDRF9cOkK9Ui/hbDeOWGZqyQALDXVCQ== + dependencies: + "@ethersproject/abi" "^5.1.2" + "@types/chai-as-promised" "^7.1.3" + chai-as-promised "^7.1.1" + deep-eql "^4.0.1" + ordinal "^1.0.3" + +"@nomicfoundation/hardhat-network-helpers@^1.0.0": + version "1.0.8" + resolved "https://registry.npmjs.org/@nomicfoundation/hardhat-network-helpers/-/hardhat-network-helpers-1.0.8.tgz" + integrity sha512-MNqQbzUJZnCMIYvlniC3U+kcavz/PhhQSsY90tbEtUyMj/IQqsLwIRZa4ctjABh3Bz0KCh9OXUZ7Yk/d9hr45Q== + dependencies: + ethereumjs-util "^7.1.4" + +"@nomicfoundation/hardhat-toolbox@^2.0.0": + version "2.0.2" + resolved "https://registry.npmjs.org/@nomicfoundation/hardhat-toolbox/-/hardhat-toolbox-2.0.2.tgz" + integrity sha512-vnN1AzxbvpSx9pfdRHbUzTRIXpMLPXnUlkW855VaDk6N1pwRaQ2gNzEmFAABk4lWf11E00PKwFd/q27HuwYrYg== + +"@nomicfoundation/hardhat-verify@2.0.3": + version "2.0.3" + resolved "https://registry.npmjs.org/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.3.tgz" + integrity sha512-ESbRu9by53wu6VvgwtMtm108RSmuNsVqXtzg061D+/4R7jaWh/Wl/8ve+p6SdDX7vA1Z3L02hDO1Q3BY4luLXQ== + dependencies: + "@ethersproject/abi" "^5.1.2" + "@ethersproject/address" "^5.0.2" + cbor "^8.1.0" + chalk "^2.4.2" + debug "^4.1.1" + lodash.clonedeep "^4.5.0" + semver "^6.3.0" + table "^6.8.0" + undici "^5.14.0" + +"@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1": + version "0.1.1" + resolved "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-arm64/-/solidity-analyzer-darwin-arm64-0.1.1.tgz" + integrity sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w== + +"@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-darwin-x64/-/solidity-analyzer-darwin-x64-0.1.1.tgz#6e25ccdf6e2d22389c35553b64fe6f3fdaec432c" + integrity sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA== + +"@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-freebsd-x64/-/solidity-analyzer-freebsd-x64-0.1.1.tgz#0a224ea50317139caeebcdedd435c28a039d169c" + integrity sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA== + +"@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-linux-arm64-gnu/-/solidity-analyzer-linux-arm64-gnu-0.1.1.tgz#dfa085d9ffab9efb2e7b383aed3f557f7687ac2b" + integrity sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg== + +"@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-linux-arm64-musl/-/solidity-analyzer-linux-arm64-musl-0.1.1.tgz#c9e06b5d513dd3ab02a7ac069c160051675889a4" + integrity sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w== + +"@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-linux-x64-gnu/-/solidity-analyzer-linux-x64-gnu-0.1.1.tgz#8d328d16839e52571f72f2998c81e46bf320f893" + integrity sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA== + +"@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-linux-x64-musl/-/solidity-analyzer-linux-x64-musl-0.1.1.tgz#9b49d0634b5976bb5ed1604a1e1b736f390959bb" + integrity sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w== + +"@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-win32-arm64-msvc/-/solidity-analyzer-win32-arm64-msvc-0.1.1.tgz#e2867af7264ebbcc3131ef837878955dd6a3676f" + integrity sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg== + +"@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-win32-ia32-msvc/-/solidity-analyzer-win32-ia32-msvc-0.1.1.tgz#0685f78608dd516c8cdfb4896ed451317e559585" + integrity sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ== + +"@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/solidity-analyzer-win32-x64-msvc/-/solidity-analyzer-win32-x64-msvc-0.1.1.tgz#c9a44f7108646f083b82e851486e0f6aeb785836" + integrity sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw== + +"@nomicfoundation/solidity-analyzer@^0.1.0": + version "0.1.1" + resolved "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer/-/solidity-analyzer-0.1.1.tgz" + integrity sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg== + optionalDependencies: + "@nomicfoundation/solidity-analyzer-darwin-arm64" "0.1.1" + "@nomicfoundation/solidity-analyzer-darwin-x64" "0.1.1" + "@nomicfoundation/solidity-analyzer-freebsd-x64" "0.1.1" + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu" "0.1.1" + "@nomicfoundation/solidity-analyzer-linux-arm64-musl" "0.1.1" + "@nomicfoundation/solidity-analyzer-linux-x64-gnu" "0.1.1" + "@nomicfoundation/solidity-analyzer-linux-x64-musl" "0.1.1" + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc" "0.1.1" + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc" "0.1.1" + "@nomicfoundation/solidity-analyzer-win32-x64-msvc" "0.1.1" + +"@nomiclabs/hardhat-ethers@^2.0.5": + version "2.2.3" + resolved "https://registry.npmjs.org/@nomiclabs/hardhat-ethers/-/hardhat-ethers-2.2.3.tgz" + integrity sha512-YhzPdzb612X591FOe68q+qXVXGG2ANZRvDo0RRUtimev85rCrAlv/TLMEZw5c+kq9AbzocLTVX/h2jVIFPL9Xg== + +"@nomiclabs/hardhat-waffle@^2.0.3": + version "2.0.5" + resolved "https://registry.npmjs.org/@nomiclabs/hardhat-waffle/-/hardhat-waffle-2.0.5.tgz" + integrity sha512-U1RH9OQ1mWYQfb+moX5aTgGjpVVlOcpiFI47wwnaGG4kLhcTy90cNiapoqZenxcRAITVbr0/+QSduINL5EsUIQ== + +"@openzeppelin/contracts-upgradeable@^4.8.3": + version "4.9.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.9.6.tgz#38b21708a719da647de4bb0e4802ee235a0d24df" + integrity sha512-m4iHazOsOCv1DgM7eD7GupTJ+NFVujRZt1wzddDPSVGpWdKq1SKkla5htKG7+IS4d2XOCtzkUNwRZ7Vq5aEUMA== + +"@openzeppelin/contracts@3.4.2-solc-0.7": + version "3.4.2-solc-0.7" + resolved "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-3.4.2-solc-0.7.tgz" + integrity sha512-W6QmqgkADuFcTLzHL8vVoNBtkwjvQRpYIAom7KiUNoLKghyx3FgH0GBjt8NRvigV1ZmMOBllvE1By1C+bi8WpA== + +"@openzeppelin/contracts@^4.3.2": + version "4.9.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.9.6.tgz#2a880a24eb19b4f8b25adc2a5095f2aa27f39677" + integrity sha512-xSmezSupL+y9VkHZJGDoCBpmnB2ogM13ccaYDWqJTfS3dbuHkgjuwDFUmaFauBCboQMGB/S5UqUl2y54X99BmA== + +"@openzeppelin/contracts@^4.8.3": + version "4.8.3" + resolved "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-4.8.3.tgz" + integrity sha512-bQHV8R9Me8IaJoJ2vPG4rXcL7seB7YVuskr4f+f5RyOStSZetwzkWtoqDMl5erkBJy0lDRUnIR2WIkPiC0GJlg== + +"@openzeppelin/defender-base-client@^1.46.0": + version "1.54.6" + resolved "https://registry.yarnpkg.com/@openzeppelin/defender-base-client/-/defender-base-client-1.54.6.tgz#b65a90dba49375ac1439d638832382344067a0b9" + integrity sha512-PTef+rMxkM5VQ7sLwLKSjp2DBakYQd661ZJiSRywx+q/nIpm3B/HYGcz5wPZCA5O/QcEP6TatXXDoeMwimbcnw== + dependencies: + amazon-cognito-identity-js "^6.0.1" + async-retry "^1.3.3" + axios "^1.4.0" + lodash "^4.17.19" + node-fetch "^2.6.0" + +"@openzeppelin/hardhat-upgrades@1.28.0": + version "1.28.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/hardhat-upgrades/-/hardhat-upgrades-1.28.0.tgz#6361f313a8a879d8a08a5e395acf0933bc190950" + integrity sha512-7sb/Jf+X+uIufOBnmHR0FJVWuxEs2lpxjJnLNN6eCJCP8nD0v+Ot5lTOW2Qb/GFnh+fLvJtEkhkowz4ZQ57+zQ== + dependencies: + "@openzeppelin/defender-base-client" "^1.46.0" + "@openzeppelin/platform-deploy-client" "^0.8.0" + "@openzeppelin/upgrades-core" "^1.27.0" + chalk "^4.1.0" + debug "^4.1.1" + proper-lockfile "^4.1.1" + +"@openzeppelin/platform-deploy-client@^0.8.0": + version "0.8.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/platform-deploy-client/-/platform-deploy-client-0.8.0.tgz#af6596275a19c283d6145f0128cc1247d18223c1" + integrity sha512-POx3AsnKwKSV/ZLOU/gheksj0Lq7Is1q2F3pKmcFjGZiibf+4kjGxr4eSMrT+2qgKYZQH1ZLQZ+SkbguD8fTvA== + dependencies: + "@ethersproject/abi" "^5.6.3" + "@openzeppelin/defender-base-client" "^1.46.0" + axios "^0.21.2" + lodash "^4.17.19" + node-fetch "^2.6.0" + +"@openzeppelin/upgrades-core@^1.27.0": + version "1.34.1" + resolved "https://registry.yarnpkg.com/@openzeppelin/upgrades-core/-/upgrades-core-1.34.1.tgz#660301692e706c7e701395467267128cc43c1de9" + integrity sha512-LV3hHm60htmP3HJjn2VoGqXNPn1RLFSSInRyXNbm15Z2oWKGxOfAWSC4+okRckum0yVB5g3k4/SEyqjsJRB07A== + dependencies: + cbor "^9.0.0" + chalk "^4.1.0" + compare-versions "^6.0.0" + debug "^4.1.1" + ethereumjs-util "^7.0.3" + minimist "^1.2.7" + proper-lockfile "^4.1.1" + solidity-ast "^0.4.51" + +"@pnpm/config.env-replace@^1.1.0": + version "1.1.0" + resolved "https://registry.npmjs.org/@pnpm/config.env-replace/-/config.env-replace-1.1.0.tgz" + integrity sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w== + +"@pnpm/network.ca-file@^1.0.1": + version "1.0.2" + resolved "https://registry.npmjs.org/@pnpm/network.ca-file/-/network.ca-file-1.0.2.tgz" + integrity sha512-YcPQ8a0jwYU9bTdJDpXjMi7Brhkr1mXsXrUJvjqM2mQDgkRiz8jFaQGOdaLxgjtUfQgZhKy/O3cG/YwmgKaxLA== + dependencies: + graceful-fs "4.2.10" + +"@pnpm/npm-conf@^2.1.0": + version "2.2.2" + resolved "https://registry.npmjs.org/@pnpm/npm-conf/-/npm-conf-2.2.2.tgz" + integrity sha512-UA91GwWPhFExt3IizW6bOeY/pQ0BkuNwKjk9iQW9KqxluGCrg4VenZ0/L+2Y0+ZOtme72EVvg6v0zo3AMQRCeA== + dependencies: + "@pnpm/config.env-replace" "^1.1.0" + "@pnpm/network.ca-file" "^1.0.1" + config-chain "^1.1.11" + +"@resolver-engine/core@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/core/-/core-0.3.3.tgz" + integrity sha512-eB8nEbKDJJBi5p5SrvrvILn4a0h42bKtbCTri3ZxCGt6UvoQyp7HnGOfki944bUjBSHKK3RvgfViHn+kqdXtnQ== + dependencies: + debug "^3.1.0" + is-url "^1.2.4" + request "^2.85.0" + +"@resolver-engine/fs@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/fs/-/fs-0.3.3.tgz" + integrity sha512-wQ9RhPUcny02Wm0IuJwYMyAG8fXVeKdmhm8xizNByD4ryZlx6PP6kRen+t/haF43cMfmaV7T3Cx6ChOdHEhFUQ== + dependencies: + "@resolver-engine/core" "^0.3.3" + debug "^3.1.0" + +"@resolver-engine/imports-fs@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/imports-fs/-/imports-fs-0.3.3.tgz" + integrity sha512-7Pjg/ZAZtxpeyCFlZR5zqYkz+Wdo84ugB5LApwriT8XFeQoLwGUj4tZFFvvCuxaNCcqZzCYbonJgmGObYBzyCA== + dependencies: + "@resolver-engine/fs" "^0.3.3" + "@resolver-engine/imports" "^0.3.3" + debug "^3.1.0" + +"@resolver-engine/imports@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/imports/-/imports-0.3.3.tgz" + integrity sha512-anHpS4wN4sRMwsAbMXhMfOD/y4a4Oo0Cw/5+rue7hSwGWsDOQaAU1ClK1OxjUC35/peazxEl8JaSRRS+Xb8t3Q== + dependencies: + "@resolver-engine/core" "^0.3.3" + debug "^3.1.0" + hosted-git-info "^2.6.0" + path-browserify "^1.0.0" + url "^0.11.0" + +"@scure/base@~1.1.0": + version "1.1.1" + resolved "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz" + integrity sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA== + +"@scure/base@~1.1.6": + version "1.1.7" + resolved "https://registry.yarnpkg.com/@scure/base/-/base-1.1.7.tgz#fe973311a5c6267846aa131bc72e96c5d40d2b30" + integrity sha512-PPNYBslrLNNUQ/Yad37MHYsNQtK67EhWb6WtSvNLLPo7SdVZgkUjD6Dg+5On7zNwmskf8OX7I7Nx5oN+MIWE0g== + +"@scure/bip32@1.1.5": + version "1.1.5" + resolved "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.5.tgz" + integrity sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw== + dependencies: + "@noble/hashes" "~1.2.0" + "@noble/secp256k1" "~1.7.0" + "@scure/base" "~1.1.0" + +"@scure/bip32@1.4.0": + version "1.4.0" + resolved "https://registry.yarnpkg.com/@scure/bip32/-/bip32-1.4.0.tgz#4e1f1e196abedcef395b33b9674a042524e20d67" + integrity sha512-sVUpc0Vq3tXCkDGYVWGIZTRfnvu8LoTDaev7vbwh0omSvVORONr960MQWdKqJDCReIEmTj3PAr73O3aoxz7OPg== + dependencies: + "@noble/curves" "~1.4.0" + "@noble/hashes" "~1.4.0" + "@scure/base" "~1.1.6" + +"@scure/bip39@1.1.1": + version "1.1.1" + resolved "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz" + integrity sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg== + dependencies: + "@noble/hashes" "~1.2.0" + "@scure/base" "~1.1.0" + +"@scure/bip39@1.3.0": + version "1.3.0" + resolved "https://registry.yarnpkg.com/@scure/bip39/-/bip39-1.3.0.tgz#0f258c16823ddd00739461ac31398b4e7d6a18c3" + integrity sha512-disdg7gHuTDZtY+ZdkmLpPCk7fxZSu3gBiEGuoC1XYxv9cGx3Z6cpTggCgW6odSOOIXCiDjuGejW+aJKCY/pIQ== + dependencies: + "@noble/hashes" "~1.4.0" + "@scure/base" "~1.1.6" + +"@sentry/core@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/core/-/core-5.30.0.tgz" + integrity sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/minimal" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/hub@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/hub/-/hub-5.30.0.tgz" + integrity sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ== + dependencies: + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/minimal@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/minimal/-/minimal-5.30.0.tgz" + integrity sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/types" "5.30.0" + tslib "^1.9.3" + +"@sentry/node@^5.18.1": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/node/-/node-5.30.0.tgz" + integrity sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg== + dependencies: + "@sentry/core" "5.30.0" + "@sentry/hub" "5.30.0" + "@sentry/tracing" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + cookie "^0.4.1" + https-proxy-agent "^5.0.0" + lru_map "^0.3.3" + tslib "^1.9.3" + +"@sentry/tracing@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/tracing/-/tracing-5.30.0.tgz" + integrity sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/minimal" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/types@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/types/-/types-5.30.0.tgz" + integrity sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw== + +"@sentry/utils@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/utils/-/utils-5.30.0.tgz" + integrity sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww== + dependencies: + "@sentry/types" "5.30.0" + tslib "^1.9.3" + +"@sindresorhus/is@^5.2.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz" + integrity sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g== + +"@smithy/types@^3.1.0": + version "3.2.0" + resolved "https://registry.yarnpkg.com/@smithy/types/-/types-3.2.0.tgz#1350fe8a50d5e35e12ffb34be46d946860b2b5ab" + integrity sha512-cKyeKAPazZRVqm7QPvcPD2jEIt2wqDPAL1KJKb0f/5I7uhollvsWZuZKLclmyP6a+Jwmr3OV3t+X0pZUUHS9BA== + dependencies: + tslib "^2.6.2" + +"@solidity-parser/parser@^0.14.0": + version "0.14.5" + resolved "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.5.tgz" + integrity sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg== + dependencies: + antlr4ts "^0.5.0-alpha.4" + +"@solidity-parser/parser@^0.18.0": + version "0.18.0" + resolved "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.18.0.tgz" + integrity sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA== + +"@szmarczak/http-timer@^5.0.1": + version "5.0.1" + resolved "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-5.0.1.tgz" + integrity sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw== + dependencies: + defer-to-connect "^2.0.1" + +"@trufflesuite/bigint-buffer@1.1.10": + version "1.1.10" + resolved "https://registry.npmjs.org/@trufflesuite/bigint-buffer/-/bigint-buffer-1.1.10.tgz" + integrity sha512-pYIQC5EcMmID74t26GCC67946mgTJFiLXOT/BYozgrd4UEY2JHEGLhWi9cMiQCt5BSqFEvKkCHNnoj82SRjiEw== + dependencies: + node-gyp-build "4.4.0" + +"@trufflesuite/bigint-buffer@1.1.9": + version "1.1.9" + resolved "https://registry.npmjs.org/@trufflesuite/bigint-buffer/-/bigint-buffer-1.1.9.tgz" + integrity sha512-bdM5cEGCOhDSwminryHJbRmXc1x7dPKg6Pqns3qyTwFlxsqUgxE29lsERS3PlIW1HTjoIGMUqsk1zQQwST1Yxw== + dependencies: + node-gyp-build "4.3.0" + +"@tsconfig/node10@^1.0.7": + version "1.0.9" + resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz" + integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA== + +"@tsconfig/node12@^1.0.7": + version "1.0.11" + resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz" + integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== + +"@tsconfig/node14@^1.0.0": + version "1.0.3" + resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz" + integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== + +"@tsconfig/node16@^1.0.2": + version "1.0.3" + resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz" + integrity sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ== + +"@typechain/ethers-v5@^10.0.0", "@typechain/ethers-v5@^10.1.0": + version "10.2.0" + resolved "https://registry.npmjs.org/@typechain/ethers-v5/-/ethers-v5-10.2.0.tgz" + integrity sha512-ikaq0N/w9fABM+G01OFmU3U3dNnyRwEahkdvi9mqy1a3XwKiPZaF/lu54OcNaEWnpvEYyhhS0N7buCtLQqC92w== + dependencies: + lodash "^4.17.15" + ts-essentials "^7.0.1" + +"@typechain/hardhat@^6.1.2": + version "6.1.5" + resolved "https://registry.npmjs.org/@typechain/hardhat/-/hardhat-6.1.5.tgz" + integrity sha512-lg7LW4qDZpxFMknp3Xool61Fg6Lays8F8TXdFGBG+MxyYcYU5795P1U2XdStuzGq9S2Dzdgh+1jGww9wvZ6r4Q== + dependencies: + fs-extra "^9.1.0" + +"@types/abstract-leveldown@*": + version "7.2.1" + resolved "https://registry.npmjs.org/@types/abstract-leveldown/-/abstract-leveldown-7.2.1.tgz" + integrity sha512-YK8irIC+eMrrmtGx0H4ISn9GgzLd9dojZWJaMbjp1YHLl2VqqNFBNrL5Q3KjGf4VE3sf/4hmq6EhQZ7kZp1NoQ== + +"@types/bn.js@^4.11.3": + version "4.11.6" + resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz" + integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg== + dependencies: + "@types/node" "*" + +"@types/bn.js@^5.1.0": + version "5.1.1" + resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz" + integrity sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g== + dependencies: + "@types/node" "*" + +"@types/chai-as-promised@^7.1.3": + version "7.1.5" + resolved "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.5.tgz" + integrity sha512-jStwss93SITGBwt/niYrkf2C+/1KTeZCZl1LaeezTlqppAKeoQC7jxyqYuP72sxBGKCIbw7oHgbYssIRzT5FCQ== + dependencies: + "@types/chai" "*" + +"@types/chai@*", "@types/chai@^4.3.1": + version "4.3.4" + resolved "https://registry.npmjs.org/@types/chai/-/chai-4.3.4.tgz" + integrity sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw== + +"@types/concat-stream@^1.6.0": + version "1.6.1" + resolved "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz" + integrity sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA== + dependencies: + "@types/node" "*" + +"@types/form-data@0.0.33": + version "0.0.33" + resolved "https://registry.npmjs.org/@types/form-data/-/form-data-0.0.33.tgz" + integrity sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw== + dependencies: + "@types/node" "*" + +"@types/glob@^7.1.1": + version "7.2.0" + resolved "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz" + integrity sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA== + dependencies: + "@types/minimatch" "*" + "@types/node" "*" + +"@types/http-cache-semantics@^4.0.2": + version "4.0.4" + resolved "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.0.4.tgz" + integrity sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA== + +"@types/inquirer@^8.2.1": + version "8.2.6" + resolved "https://registry.npmjs.org/@types/inquirer/-/inquirer-8.2.6.tgz" + integrity sha512-3uT88kxg8lNzY8ay2ZjP44DKcRaTGztqeIvN2zHvhzIBH/uAPaL75aBtdNRKbA7xXoMbBt5kX0M00VKAnfOYlA== + dependencies: + "@types/through" "*" + rxjs "^7.2.0" + +"@types/is-ci@^3.0.0": + version "3.0.0" + resolved "https://registry.npmjs.org/@types/is-ci/-/is-ci-3.0.0.tgz" + integrity sha512-Q0Op0hdWbYd1iahB+IFNQcWXFq4O0Q5MwQP7uN0souuQ4rPg1vEYcnIOfr1gY+M+6rc8FGoRaBO1mOOvL29sEQ== + dependencies: + ci-info "^3.1.0" + +"@types/json-schema@^7.0.9": + version "7.0.11" + resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz" + integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== + +"@types/json5@^0.0.29": + version "0.0.29" + resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz" + integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ== + +"@types/level-errors@*": + version "3.0.0" + resolved "https://registry.npmjs.org/@types/level-errors/-/level-errors-3.0.0.tgz" + integrity sha512-/lMtoq/Cf/2DVOm6zE6ORyOM+3ZVm/BvzEZVxUhf6bgh8ZHglXlBqxbxSlJeVp8FCbD3IVvk/VbsaNmDjrQvqQ== + +"@types/levelup@^4.3.0": + version "4.3.3" + resolved "https://registry.npmjs.org/@types/levelup/-/levelup-4.3.3.tgz" + integrity sha512-K+OTIjJcZHVlZQN1HmU64VtrC0jC3dXWQozuEIR9zVvltIk90zaGPM2AgT+fIkChpzHhFE3YnvFLCbLtzAmexA== + dependencies: + "@types/abstract-leveldown" "*" + "@types/level-errors" "*" + "@types/node" "*" + +"@types/lru-cache@5.1.1", "@types/lru-cache@^5.1.0": + version "5.1.1" + resolved "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz" + integrity sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw== + +"@types/minimatch@*": + version "5.1.2" + resolved "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz" + integrity sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA== + +"@types/minimist@^1.2.0", "@types/minimist@^1.2.2": + version "1.2.2" + resolved "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz" + integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ== + +"@types/mkdirp@^0.5.2": + version "0.5.2" + resolved "https://registry.npmjs.org/@types/mkdirp/-/mkdirp-0.5.2.tgz" + integrity sha512-U5icWpv7YnZYGsN4/cmh3WD2onMY0aJIiTE6+51TwJCttdHvtCYmkBNOobHlXwrJRL0nkH9jH4kD+1FAdMN4Tg== + dependencies: + "@types/node" "*" + +"@types/mocha@^10.0.1": + version "10.0.1" + resolved "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz" + integrity sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q== + +"@types/node-fetch@^2.6.1": + version "2.6.3" + resolved "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.3.tgz" + integrity sha512-ETTL1mOEdq/sxUtgtOhKjyB2Irra4cjxksvcMUR5Zr4n+PxVhsCD9WS46oPbHL3et9Zde7CNRr+WUNlcHvsX+w== + dependencies: + "@types/node" "*" + form-data "^3.0.0" + +"@types/node@*", "@types/node@^17.0.25": + version "17.0.45" + resolved "https://registry.npmjs.org/@types/node/-/node-17.0.45.tgz" + integrity sha512-w+tIMs3rq2afQdsPJlODhoUEKzFP1ayaoyl1CcnwtIlsVe7K7bA1NGm4s3PraqTLlXnbIN84zuBlxBWo1u9BLw== + +"@types/node@11.11.6": + version "11.11.6" + resolved "https://registry.npmjs.org/@types/node/-/node-11.11.6.tgz" + integrity sha512-Exw4yUWMBXM3X+8oqzJNRqZSwUAaS4+7NdvHqQuFi/d+synz++xmX3QIf+BFqneW8N31R8Ky+sikfZUXq07ggQ== + +"@types/node@^10.0.3": + version "10.17.60" + resolved "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz" + integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw== + +"@types/node@^12.7.1": + version "12.20.55" + resolved "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz" + integrity sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ== + +"@types/node@^8.0.0": + version "8.10.66" + resolved "https://registry.npmjs.org/@types/node/-/node-8.10.66.tgz" + integrity sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw== + +"@types/normalize-package-data@^2.4.0": + version "2.4.1" + resolved "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz" + integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw== + +"@types/pbkdf2@^3.0.0": + version "3.1.0" + resolved "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz" + integrity sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ== + dependencies: + "@types/node" "*" + +"@types/prettier@^2.1.1": + version "2.7.2" + resolved "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz" + integrity sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg== + +"@types/qs@^6.2.31": + version "6.9.7" + resolved "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz" + integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw== + +"@types/readable-stream@^2.3.13": + version "2.3.15" + resolved "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-2.3.15.tgz" + integrity sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ== + dependencies: + "@types/node" "*" + safe-buffer "~5.1.1" + +"@types/secp256k1@^4.0.1": + version "4.0.3" + resolved "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz" + integrity sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w== + dependencies: + "@types/node" "*" + +"@types/seedrandom@3.0.1": + version "3.0.1" + resolved "https://registry.npmjs.org/@types/seedrandom/-/seedrandom-3.0.1.tgz" + integrity sha512-giB9gzDeiCeloIXDgzFBCgjj1k4WxcDrZtGl6h1IqmUPlxF+Nx8Ve+96QCyDZ/HseB/uvDsKbpib9hU5cU53pw== + +"@types/semver@^6.0.0": + version "6.2.3" + resolved "https://registry.npmjs.org/@types/semver/-/semver-6.2.3.tgz" + integrity sha512-KQf+QAMWKMrtBMsB8/24w53tEsxllMj6TuA80TT/5igJalLI/zm0L3oXRbIAl4Ohfc85gyHX/jhMwsVkmhLU4A== + +"@types/semver@^7.3.12": + version "7.3.13" + resolved "https://registry.npmjs.org/@types/semver/-/semver-7.3.13.tgz" + integrity sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw== + +"@types/through@*": + version "0.0.30" + resolved "https://registry.npmjs.org/@types/through/-/through-0.0.30.tgz" + integrity sha512-FvnCJljyxhPM3gkRgWmxmDZyAQSiBQQWLI0A0VFL0K7W1oRUrPJSqNO0NvTnLkBcotdlp3lKvaT0JrnyRDkzOg== + dependencies: + "@types/node" "*" + +"@typescript-eslint/eslint-plugin@^5.20.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.58.0.tgz" + integrity sha512-vxHvLhH0qgBd3/tW6/VccptSfc8FxPQIkmNTVLWcCOVqSBvqpnKkBTYrhcGlXfSnd78azwe+PsjYFj0X34/njA== + dependencies: + "@eslint-community/regexpp" "^4.4.0" + "@typescript-eslint/scope-manager" "5.58.0" + "@typescript-eslint/type-utils" "5.58.0" + "@typescript-eslint/utils" "5.58.0" + debug "^4.3.4" + grapheme-splitter "^1.0.4" + ignore "^5.2.0" + natural-compare-lite "^1.4.0" + semver "^7.3.7" + tsutils "^3.21.0" + +"@typescript-eslint/experimental-utils@^5.0.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-5.58.0.tgz" + integrity sha512-LA/sRPaynZlrlYxdefrZbMx8dqs/1Kc0yNG+XOk5CwwZx7tTv263ix3AJNioF0YBVt7hADpAUR20owl6pv4MIQ== + dependencies: + "@typescript-eslint/utils" "5.58.0" + +"@typescript-eslint/parser@^5.20.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.58.0.tgz" + integrity sha512-ixaM3gRtlfrKzP8N6lRhBbjTow1t6ztfBvQNGuRM8qH1bjFFXIJ35XY+FC0RRBKn3C6cT+7VW1y8tNm7DwPHDQ== + dependencies: + "@typescript-eslint/scope-manager" "5.58.0" + "@typescript-eslint/types" "5.58.0" + "@typescript-eslint/typescript-estree" "5.58.0" + debug "^4.3.4" + +"@typescript-eslint/scope-manager@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.58.0.tgz" + integrity sha512-b+w8ypN5CFvrXWQb9Ow9T4/6LC2MikNf1viLkYTiTbkQl46CnR69w7lajz1icW0TBsYmlpg+mRzFJ4LEJ8X9NA== + dependencies: + "@typescript-eslint/types" "5.58.0" + "@typescript-eslint/visitor-keys" "5.58.0" + +"@typescript-eslint/type-utils@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.58.0.tgz" + integrity sha512-FF5vP/SKAFJ+LmR9PENql7fQVVgGDOS+dq3j+cKl9iW/9VuZC/8CFmzIP0DLKXfWKpRHawJiG70rVH+xZZbp8w== + dependencies: + "@typescript-eslint/typescript-estree" "5.58.0" + "@typescript-eslint/utils" "5.58.0" + debug "^4.3.4" + tsutils "^3.21.0" + +"@typescript-eslint/types@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.58.0.tgz" + integrity sha512-JYV4eITHPzVQMnHZcYJXl2ZloC7thuUHrcUmxtzvItyKPvQ50kb9QXBkgNAt90OYMqwaodQh2kHutWZl1fc+1g== + +"@typescript-eslint/typescript-estree@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.58.0.tgz" + integrity sha512-cRACvGTodA+UxnYM2uwA2KCwRL7VAzo45syNysqlMyNyjw0Z35Icc9ihPJZjIYuA5bXJYiJ2YGUB59BqlOZT1Q== + dependencies: + "@typescript-eslint/types" "5.58.0" + "@typescript-eslint/visitor-keys" "5.58.0" + debug "^4.3.4" + globby "^11.1.0" + is-glob "^4.0.3" + semver "^7.3.7" + tsutils "^3.21.0" + +"@typescript-eslint/utils@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.58.0.tgz" + integrity sha512-gAmLOTFXMXOC+zP1fsqm3VceKSBQJNzV385Ok3+yzlavNHZoedajjS4UyS21gabJYcobuigQPs/z71A9MdJFqQ== + dependencies: + "@eslint-community/eslint-utils" "^4.2.0" + "@types/json-schema" "^7.0.9" + "@types/semver" "^7.3.12" + "@typescript-eslint/scope-manager" "5.58.0" + "@typescript-eslint/types" "5.58.0" + "@typescript-eslint/typescript-estree" "5.58.0" + eslint-scope "^5.1.1" + semver "^7.3.7" + +"@typescript-eslint/visitor-keys@5.58.0": + version "5.58.0" + resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.58.0.tgz" + integrity sha512-/fBraTlPj0jwdyTwLyrRTxv/3lnU2H96pNTVM6z3esTWLtA5MZ9ghSMJ7Rb+TtUAdtEw9EyJzJ0EydIMKxQ9gA== + dependencies: + "@typescript-eslint/types" "5.58.0" + eslint-visitor-keys "^3.3.0" + +"@uniswap/lib@1.1.1": + version "1.1.1" + resolved "https://registry.npmjs.org/@uniswap/lib/-/lib-1.1.1.tgz" + integrity sha512-2yK7sLpKIT91TiS5sewHtOa7YuM8IuBXVl4GZv2jZFys4D2sY7K5vZh6MqD25TPA95Od+0YzCVq6cTF2IKrOmg== + +"@uniswap/lib@^4.0.1-alpha": + version "4.0.1-alpha" + resolved "https://registry.npmjs.org/@uniswap/lib/-/lib-4.0.1-alpha.tgz" + integrity sha512-f6UIliwBbRsgVLxIaBANF6w09tYqc6Y/qXdsrbEmXHyFA7ILiKrIwRFXe1yOg8M3cksgVsO9N7yuL2DdCGQKBA== + +"@uniswap/v2-core@1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@uniswap/v2-core/-/v2-core-1.0.0.tgz" + integrity sha512-BJiXrBGnN8mti7saW49MXwxDBRFiWemGetE58q8zgfnPPzQKq55ADltEILqOt6VFZ22kVeVKbF8gVd8aY3l7pA== + +"@uniswap/v2-core@1.0.1", "@uniswap/v2-core@^1.0.1": + version "1.0.1" + resolved "https://registry.npmjs.org/@uniswap/v2-core/-/v2-core-1.0.1.tgz" + integrity sha512-MtybtkUPSyysqLY2U210NBDeCHX+ltHt3oADGdjqoThZaFRDKwM6k1Nb3F0A3hk5hwuQvytFWhrWHOEq6nVJ8Q== + +"@uniswap/v2-periphery@1.1.0-beta.0", "@uniswap/v2-periphery@^1.1.0-beta.0": + version "1.1.0-beta.0" + resolved "https://registry.npmjs.org/@uniswap/v2-periphery/-/v2-periphery-1.1.0-beta.0.tgz" + integrity sha512-6dkwAMKza8nzqYiXEr2D86dgW3TTavUvCR0w2Tu33bAbM8Ah43LKAzH7oKKPRT5VJQaMi1jtkGs1E8JPor1n5g== + dependencies: + "@uniswap/lib" "1.1.1" + "@uniswap/v2-core" "1.0.0" + +"@uniswap/v3-core@1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@uniswap/v3-core/-/v3-core-1.0.0.tgz" + integrity sha512-kSC4djMGKMHj7sLMYVnn61k9nu+lHjMIxgg9CDQT+s2QYLoA56GbSK9Oxr+qJXzzygbkrmuY6cwgP6cW2JXPFA== + +"@uniswap/v3-periphery@^1.4.3": + version "1.4.3" + resolved "https://registry.npmjs.org/@uniswap/v3-periphery/-/v3-periphery-1.4.3.tgz" + integrity sha512-80c+wtVzl5JJT8UQskxVYYG3oZb4pkhY0zDe0ab/RX4+8f9+W5d8wI4BT0wLB0wFQTSnbW+QdBSpkHA/vRyGBA== + dependencies: + "@openzeppelin/contracts" "3.4.2-solc-0.7" + "@uniswap/lib" "^4.0.1-alpha" + "@uniswap/v2-core" "1.0.1" + "@uniswap/v3-core" "1.0.0" + base64-sol "1.0.1" + +"@zetachain/networks@6.0.0": + version "6.0.0" + resolved "https://registry.npmjs.org/@zetachain/networks/-/networks-6.0.0.tgz" + integrity sha512-yKFVP/yJDp76Q5lBGfZSpY/KO3TZ9ldo0lhE4MpBW43EsBxOZWixg6sqb56mcU/gg1lbWG8sHHWtYFK51SByjQ== + dependencies: + dotenv "^16.1.4" + +abbrev@1: + version "1.1.1" + resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz" + integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q== + +abbrev@1.0.x: + version "1.0.9" + resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz" + integrity sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q== + +abort-controller@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz" + integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== + dependencies: + event-target-shim "^5.0.0" + +abstract-level@^1.0.0, abstract-level@^1.0.2, abstract-level@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/abstract-level/-/abstract-level-1.0.3.tgz" + integrity sha512-t6jv+xHy+VYwc4xqZMn2Pa9DjcdzvzZmQGRjTFc8spIbRGHgBrEKbPq+rYXc7CCo0lxgYvSgKVg9qZAhpVQSjA== + dependencies: + buffer "^6.0.3" + catering "^2.1.0" + is-buffer "^2.0.5" + level-supports "^4.0.0" + level-transcoder "^1.0.1" + module-error "^1.0.1" + queue-microtask "^1.2.3" + +abstract-leveldown@^6.2.1: + version "6.3.0" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-6.3.0.tgz" + integrity sha512-TU5nlYgta8YrBMNpc9FwQzRbiXsj49gsALsXadbGHt9CROPzX5fB0rWDR5mtdpOOKa5XqRFpbj1QroPAoPzVjQ== + dependencies: + buffer "^5.5.0" + immediate "^3.2.3" + level-concat-iterator "~2.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +abstract-leveldown@^7.2.0: + version "7.2.0" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-7.2.0.tgz" + integrity sha512-DnhQwcFEaYsvYDnACLZhMmCWd3rkOeEvglpa4q5i/5Jlm3UIsWaxVzuXvDLFCSCWRO3yy2/+V/G7FusFgejnfQ== + dependencies: + buffer "^6.0.3" + catering "^2.0.0" + is-buffer "^2.0.5" + level-concat-iterator "^3.0.0" + level-supports "^2.0.1" + queue-microtask "^1.2.3" + +abstract-leveldown@~6.2.1: + version "6.2.3" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-6.2.3.tgz" + integrity sha512-BsLm5vFMRUrrLeCcRc+G0t2qOaTzpoJQLOubq2XM72eNpjF5UdU5o/5NvlNhx95XHcAvcl8OMXr4mlg/fRgUXQ== + dependencies: + buffer "^5.5.0" + immediate "^3.2.3" + level-concat-iterator "~2.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +acorn-jsx@^5.2.0, acorn-jsx@^5.3.2: + version "5.3.2" + resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== + +acorn-walk@^8.1.1: + version "8.2.0" + resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz" + integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== + +acorn@^7.1.1: + version "7.4.1" + resolved "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz" + integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== + +acorn@^8.4.1, acorn@^8.8.0: + version "8.8.2" + resolved "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz" + integrity sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw== + +adm-zip@^0.4.16: + version "0.4.16" + resolved "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.16.tgz" + integrity sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg== + +aes-js@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz" + integrity sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw== + +agent-base@6: + version "6.0.2" + resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz" + integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ== + dependencies: + debug "4" + +aggregate-error@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz" + integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA== + dependencies: + clean-stack "^2.0.0" + indent-string "^4.0.0" + +aggregate-error@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-4.0.1.tgz" + integrity sha512-0poP0T7el6Vq3rstR8Mn4V/IQrpBLO6POkUSrN7RhyY+GF/InCFShQzsQ39T25gkHhLgSLByyAz+Kjb+c2L98w== + dependencies: + clean-stack "^4.0.0" + indent-string "^5.0.0" + +ajv@^6.10.0, ajv@^6.12.3, ajv@^6.12.4, ajv@^6.12.6: + version "6.12.6" + resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +ajv@^8.0.1: + version "8.12.0" + resolved "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz" + integrity sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA== + dependencies: + fast-deep-equal "^3.1.1" + json-schema-traverse "^1.0.0" + require-from-string "^2.0.2" + uri-js "^4.2.2" + +amazon-cognito-identity-js@^6.0.1: + version "6.3.12" + resolved "https://registry.yarnpkg.com/amazon-cognito-identity-js/-/amazon-cognito-identity-js-6.3.12.tgz#af73df033094ad4c679c19cf6122b90058021619" + integrity sha512-s7NKDZgx336cp+oDeUtB2ZzT8jWJp/v2LWuYl+LQtMEODe22RF1IJ4nRiDATp+rp1pTffCZcm44Quw4jx2bqNg== + dependencies: + "@aws-crypto/sha256-js" "1.2.2" + buffer "4.9.2" + fast-base64-decode "^1.0.0" + isomorphic-unfetch "^3.0.0" + js-cookie "^2.2.1" + +amdefine@>=0.0.4: + version "1.0.1" + resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz" + integrity sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg== + +ansi-colors@3.2.3: + version "3.2.3" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz" + integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw== + +ansi-colors@4.1.1: + version "4.1.1" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz" + integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA== + +ansi-colors@^4.1.0, ansi-colors@^4.1.1, ansi-colors@^4.1.3: + version "4.1.3" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz" + integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw== + +ansi-escapes@^4.2.1, ansi-escapes@^4.3.0: + version "4.3.2" + resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz" + integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== + dependencies: + type-fest "^0.21.3" + +ansi-regex@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz" + integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw== + +ansi-regex@^4.1.0: + version "4.1.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz" + integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g== + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-styles@^3.2.0, ansi-styles@^3.2.1: + version "3.2.1" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz" + integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== + dependencies: + color-convert "^1.9.0" + +ansi-styles@^4.0.0, ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +antlr4@^4.13.1-patch-1: + version "4.13.1-patch-1" + resolved "https://registry.npmjs.org/antlr4/-/antlr4-4.13.1-patch-1.tgz" + integrity sha512-OjFLWWLzDMV9rdFhpvroCWR4ooktNg9/nvVYSA5z28wuVpU36QUNuioR1XLnQtcjVlf8npjyz593PxnU/f/Cow== + +antlr4ts@^0.5.0-alpha.4: + version "0.5.0-alpha.4" + resolved "https://registry.npmjs.org/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz" + integrity sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ== + +anymatch@^1.3.0: + version "1.3.2" + resolved "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz" + integrity sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA== + dependencies: + micromatch "^2.1.5" + normalize-path "^2.0.0" + +anymatch@~3.1.1, anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +arg@^4.1.0: + version "4.1.3" + resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz" + integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== + +argparse@^1.0.7: + version "1.0.10" + resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +arr-diff@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz" + integrity sha512-dtXTVMkh6VkEEA7OhXnN1Ecb8aAGFdZ1LFxtOCoqj4qkyOJMt7+qs6Ahdy6p/NQCPYsRSXXivhSB/J5E9jmYKA== + dependencies: + arr-flatten "^1.0.1" + +arr-diff@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz" + integrity sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA== + +arr-flatten@^1.0.1, arr-flatten@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz" + integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg== + +arr-union@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz" + integrity sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q== + +array-back@^3.0.1, array-back@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz" + integrity sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q== + +array-back@^4.0.1, array-back@^4.0.2: + version "4.0.2" + resolved "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz" + integrity sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg== + +array-buffer-byte-length@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz" + integrity sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A== + dependencies: + call-bind "^1.0.2" + is-array-buffer "^3.0.1" + +array-buffer-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/array-buffer-byte-length/-/array-buffer-byte-length-1.0.1.tgz#1e5583ec16763540a27ae52eed99ff899223568f" + integrity sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg== + dependencies: + call-bind "^1.0.5" + is-array-buffer "^3.0.4" + +array-includes@^3.1.6: + version "3.1.6" + resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.6.tgz" + integrity sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + get-intrinsic "^1.1.3" + is-string "^1.0.7" + +array-union@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz" + integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw== + +array-uniq@1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz" + integrity sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q== + +array-unique@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz" + integrity sha512-G2n5bG5fSUCpnsXz4+8FUkYsGPkNfLn9YvS66U5qbTIXI2Ynnlo4Bi42bWv+omKUCqz+ejzfClwne0alJWJPhg== + +array-unique@^0.3.2: + version "0.3.2" + resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz" + integrity sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ== + +array.prototype.findlast@^1.2.2: + version "1.2.5" + resolved "https://registry.yarnpkg.com/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz#3e4fbcb30a15a7f5bf64cf2faae22d139c2e4904" + integrity sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.2" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-shim-unscopables "^1.0.2" + +array.prototype.flat@^1.2.3, array.prototype.flat@^1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.1.tgz" + integrity sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + es-shim-unscopables "^1.0.0" + +array.prototype.flatmap@^1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.1.tgz" + integrity sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + es-shim-unscopables "^1.0.0" + +array.prototype.reduce@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/array.prototype.reduce/-/array.prototype.reduce-1.0.5.tgz" + integrity sha512-kDdugMl7id9COE8R7MHF5jWk7Dqt/fs4Pv+JXoICnYwqpjjjbUurz6w5fT5IG6brLdJhv6/VoHB0H7oyIBXd+Q== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + es-array-method-boxes-properly "^1.0.0" + is-string "^1.0.7" + +arraybuffer.prototype.slice@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz#097972f4255e41bc3425e37dc3f6421cf9aefde6" + integrity sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A== + dependencies: + array-buffer-byte-length "^1.0.1" + call-bind "^1.0.5" + define-properties "^1.2.1" + es-abstract "^1.22.3" + es-errors "^1.2.1" + get-intrinsic "^1.2.3" + is-array-buffer "^3.0.4" + is-shared-array-buffer "^1.0.2" + +arrify@^1.0.0, arrify@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz" + integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA== + +asap@~2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz" + integrity sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA== + +asn1@~0.2.3: + version "0.2.6" + resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz" + integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== + dependencies: + safer-buffer "~2.1.0" + +assert-plus@1.0.0, assert-plus@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz" + integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw== + +assertion-error@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz" + integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== + +assign-symbols@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz" + integrity sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw== + +ast-parents@^0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/ast-parents/-/ast-parents-0.0.1.tgz" + integrity sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA== + +astral-regex@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz" + integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ== + +async-each@^1.0.0: + version "1.0.6" + resolved "https://registry.npmjs.org/async-each/-/async-each-1.0.6.tgz" + integrity sha512-c646jH1avxr+aVpndVMeAfYw7wAa6idufrlN3LPA4PmKS0QEGp6PIC9nwz0WQkkvBGAMEki3pFdtxaF39J9vvg== + +async-eventemitter@^0.2.4: + version "0.2.4" + resolved "https://registry.npmjs.org/async-eventemitter/-/async-eventemitter-0.2.4.tgz" + integrity sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw== + dependencies: + async "^2.4.0" + +async-retry@^1.3.3: + version "1.3.3" + resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.3.3.tgz#0e7f36c04d8478e7a58bdbed80cedf977785f280" + integrity sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw== + dependencies: + retry "0.13.1" + +async@1.x: + version "1.5.2" + resolved "https://registry.npmjs.org/async/-/async-1.5.2.tgz" + integrity sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w== + +async@^2.4.0: + version "2.6.4" + resolved "https://registry.npmjs.org/async/-/async-2.6.4.tgz" + integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA== + dependencies: + lodash "^4.17.14" + +asynckit@^0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz" + integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== + +at-least-node@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz" + integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg== + +atob@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz" + integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg== + +available-typed-arrays@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz" + integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw== + +available-typed-arrays@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz#a5cc375d6a03c2efc87a553f3e0b1522def14846" + integrity sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ== + dependencies: + possible-typed-array-names "^1.0.0" + +aws-sign2@~0.7.0: + version "0.7.0" + resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz" + integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA== + +aws4@^1.8.0: + version "1.12.0" + resolved "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz" + integrity sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg== + +axios@^0.21.2: + version "0.21.4" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.4.tgz#c67b90dc0568e5c1cf2b0b858c43ba28e2eda575" + integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg== + dependencies: + follow-redirects "^1.14.0" + +axios@^1.4.0: + version "1.7.2" + resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.2.tgz#b625db8a7051fbea61c35a3cbb3a1daa7b9c7621" + integrity sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw== + dependencies: + follow-redirects "^1.15.6" + form-data "^4.0.0" + proxy-from-env "^1.1.0" + +axios@^1.6.5: + version "1.6.5" + resolved "https://registry.npmjs.org/axios/-/axios-1.6.5.tgz" + integrity sha512-Ii012v05KEVuUoFWmMW/UQv9aRIc3ZwkWDcM+h5Il8izZCtRVpDUfwpoFf7eOtajT3QiGR4yDUx7lPqHJULgbg== + dependencies: + follow-redirects "^1.15.4" + form-data "^4.0.0" + proxy-from-env "^1.1.0" + +babel-runtime@^6.9.2: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz" + integrity sha512-ITKNuq2wKlW1fJg9sSW52eepoYgZBggvOAHC0u/CYu/qxQ9EVzThCgR69BnSXLHjy2f7SY5zaQ4yt7H9ZVxY2g== + dependencies: + core-js "^2.4.0" + regenerator-runtime "^0.11.0" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +base-x@^3.0.2: + version "3.0.9" + resolved "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz" + integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ== + dependencies: + safe-buffer "^5.0.1" + +base64-js@^1.0.2, base64-js@^1.3.1: + version "1.5.1" + resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" + integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== + +base64-sol@1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/base64-sol/-/base64-sol-1.0.1.tgz" + integrity sha512-ld3cCNMeXt4uJXmLZBHFGMvVpK9KsLVEhPpFRXnvSVAqABKbuNZg/+dsq3NuM+wxFLb/UrVkz7m1ciWmkMfTbg== + +base@^0.11.1: + version "0.11.2" + resolved "https://registry.npmjs.org/base/-/base-0.11.2.tgz" + integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg== + dependencies: + cache-base "^1.0.1" + class-utils "^0.3.5" + component-emitter "^1.2.1" + define-property "^1.0.0" + isobject "^3.0.1" + mixin-deep "^1.2.0" + pascalcase "^0.1.1" + +bcrypt-pbkdf@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz" + integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w== + dependencies: + tweetnacl "^0.14.3" + +bech32@1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz" + integrity sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ== + +better-path-resolve@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/better-path-resolve/-/better-path-resolve-1.0.0.tgz" + integrity sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g== + dependencies: + is-windows "^1.0.0" + +bigint-crypto-utils@^3.0.23: + version "3.2.2" + resolved "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.2.2.tgz" + integrity sha512-U1RbE3aX9ayCUVcIPHuPDPKcK3SFOXf93J1UK/iHlJuQB7bhagPIX06/CLpLEsDThJ7KA4Dhrnzynl+d2weTiw== + +bignumber.js@^9.0.0: + version "9.1.1" + resolved "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz" + integrity sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig== + +binary-extensions@^1.0.0: + version "1.13.1" + resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz" + integrity sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw== + +binary-extensions@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz" + integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA== + +bindings@^1.2.1, bindings@^1.5.0: + version "1.5.0" + resolved "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz" + integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ== + dependencies: + file-uri-to-path "1.0.0" + +bip39@3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/bip39/-/bip39-3.0.4.tgz" + integrity sha512-YZKQlb752TrUWqHWj7XAwCSjYEgGAk+/Aas3V7NyjQeZYsztO8JnQUaCWhcnL4T+jL8nvB8typ2jRPzTlgugNw== + dependencies: + "@types/node" "11.11.6" + create-hash "^1.1.0" + pbkdf2 "^3.0.9" + randombytes "^2.0.1" + +bip66@^1.1.5: + version "1.1.5" + resolved "https://registry.npmjs.org/bip66/-/bip66-1.1.5.tgz" + integrity sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw== + dependencies: + safe-buffer "^5.0.1" + +bl@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz" + integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w== + dependencies: + buffer "^5.5.0" + inherits "^2.0.4" + readable-stream "^3.4.0" + +blakejs@^1.1.0: + version "1.2.1" + resolved "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz" + integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ== + +bn.js@4.11.6: + version "4.11.6" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz" + integrity sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA== + +bn.js@^4.0.0, bn.js@^4.11.0, bn.js@^4.11.1, bn.js@^4.11.8, bn.js@^4.11.9: + version "4.12.0" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz" + integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA== + +bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1: + version "5.2.1" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz" + integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ== + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +braces@^1.8.2: + version "1.8.5" + resolved "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz" + integrity sha512-xU7bpz2ytJl1bH9cgIurjpg/n8Gohy9GTw81heDYLJQ4RU60dlyJsa+atVF2pI0yMMvKxI9HkKwjePCj5XI1hw== + dependencies: + expand-range "^1.8.1" + preserve "^0.2.0" + repeat-element "^1.1.2" + +braces@^2.3.1: + version "2.3.2" + resolved "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz" + integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w== + dependencies: + arr-flatten "^1.1.0" + array-unique "^0.3.2" + extend-shallow "^2.0.1" + fill-range "^4.0.0" + isobject "^3.0.1" + repeat-element "^1.1.2" + snapdragon "^0.8.1" + snapdragon-node "^2.0.1" + split-string "^3.0.2" + to-regex "^3.0.1" + +braces@^3.0.2, braces@~3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz" + integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== + dependencies: + fill-range "^7.0.1" + +breakword@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/breakword/-/breakword-1.0.5.tgz" + integrity sha512-ex5W9DoOQ/LUEU3PMdLs9ua/CYZl1678NUkKOdUSi8Aw5F1idieaiRURCBFJCwVcrD1J8Iy3vfWSloaMwO2qFg== + dependencies: + wcwidth "^1.0.1" + +brorand@^1.0.1, brorand@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz" + integrity sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w== + +browser-level@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/browser-level/-/browser-level-1.0.1.tgz" + integrity sha512-XECYKJ+Dbzw0lbydyQuJzwNXtOpbMSq737qxJN11sIRTErOMShvDpbzTlgju7orJKvx4epULolZAuJGLzCmWRQ== + dependencies: + abstract-level "^1.0.2" + catering "^2.1.1" + module-error "^1.0.2" + run-parallel-limit "^1.1.0" + +browser-stdout@1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz" + integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw== + +browserify-aes@^1.0.6, browserify-aes@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz" + integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA== + dependencies: + buffer-xor "^1.0.3" + cipher-base "^1.0.0" + create-hash "^1.1.0" + evp_bytestokey "^1.0.3" + inherits "^2.0.1" + safe-buffer "^5.0.1" + +bs58@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz" + integrity sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw== + dependencies: + base-x "^3.0.2" + +bs58check@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz" + integrity sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA== + dependencies: + bs58 "^4.0.0" + create-hash "^1.1.0" + safe-buffer "^5.1.2" + +buffer-from@^1.0.0, buffer-from@^1.1.0: + version "1.1.2" + resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz" + integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== + +buffer-xor@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz" + integrity sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ== + +buffer-xor@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-2.0.2.tgz" + integrity sha512-eHslX0bin3GB+Lx2p7lEYRShRewuNZL3fUl4qlVJGGiwoPGftmt8JQgk2Y9Ji5/01TnVDo33E5b5O3vUB1HdqQ== + dependencies: + safe-buffer "^5.1.1" + +buffer@4.9.2: + version "4.9.2" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-4.9.2.tgz#230ead344002988644841ab0244af8c44bbe3ef8" + integrity sha512-xq+q3SRMOxGivLhBNaUdC64hDTQwejJ+H0T/NB1XMtTVEwNTrfFF3gAxiyW0Bu/xWEGhjVKgUcMhCrUy2+uCWg== + dependencies: + base64-js "^1.0.2" + ieee754 "^1.1.4" + isarray "^1.0.0" + +buffer@^5.5.0, buffer@^5.6.0: + version "5.7.1" + resolved "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz" + integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.1.13" + +buffer@^6.0.3: + version "6.0.3" + resolved "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz" + integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.2.1" + +bufferutil@4.0.5: + version "4.0.5" + resolved "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.5.tgz" + integrity sha512-HTm14iMQKK2FjFLRTM5lAVcyaUzOnqbPtesFIvREgXpJHdQm8bWS+GkQgIkfaBYRHuCnea7w8UVNfwiAQhlr9A== + dependencies: + node-gyp-build "^4.3.0" + +busboy@^1.6.0: + version "1.6.0" + resolved "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz" + integrity sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA== + dependencies: + streamsearch "^1.1.0" + +bytes@3.1.2: + version "3.1.2" + resolved "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz" + integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== + +cache-base@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz" + integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ== + dependencies: + collection-visit "^1.0.0" + component-emitter "^1.2.1" + get-value "^2.0.6" + has-value "^1.0.0" + isobject "^3.0.1" + set-value "^2.0.0" + to-object-path "^0.3.0" + union-value "^1.0.0" + unset-value "^1.0.0" + +cacheable-lookup@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-7.0.0.tgz" + integrity sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w== + +cacheable-request@^10.2.8: + version "10.2.14" + resolved "https://registry.npmjs.org/cacheable-request/-/cacheable-request-10.2.14.tgz" + integrity sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ== + dependencies: + "@types/http-cache-semantics" "^4.0.2" + get-stream "^6.0.1" + http-cache-semantics "^4.1.1" + keyv "^4.5.3" + mimic-response "^4.0.0" + normalize-url "^8.0.0" + responselike "^3.0.0" + +call-bind@^1.0.0, call-bind@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz" + integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA== + dependencies: + function-bind "^1.1.1" + get-intrinsic "^1.0.2" + +call-bind@^1.0.5, call-bind@^1.0.6, call-bind@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.7.tgz#06016599c40c56498c18769d2730be242b6fa3b9" + integrity sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w== + dependencies: + es-define-property "^1.0.0" + es-errors "^1.3.0" + function-bind "^1.1.2" + get-intrinsic "^1.2.4" + set-function-length "^1.2.1" + +callsites@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz" + integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== + +camelcase-keys@^6.2.2: + version "6.2.2" + resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-6.2.2.tgz" + integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg== + dependencies: + camelcase "^5.3.1" + map-obj "^4.0.0" + quick-lru "^4.0.1" + +camelcase-keys@^7.0.0: + version "7.0.2" + resolved "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-7.0.2.tgz" + integrity sha512-Rjs1H+A9R+Ig+4E/9oyB66UC5Mj9Xq3N//vcLf2WzgdTi/3gUu3Z9KoqmlrEG4VuuLK8wJHofxzdQXz/knhiYg== + dependencies: + camelcase "^6.3.0" + map-obj "^4.1.0" + quick-lru "^5.1.1" + type-fest "^1.2.1" + +camelcase@^5.0.0, camelcase@^5.3.1: + version "5.3.1" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz" + integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== + +camelcase@^6.0.0, camelcase@^6.3.0: + version "6.3.0" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz" + integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== + +case@^1.6.3: + version "1.6.3" + resolved "https://registry.npmjs.org/case/-/case-1.6.3.tgz" + integrity sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ== + +caseless@^0.12.0, caseless@~0.12.0: + version "0.12.0" + resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz" + integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw== + +catering@^2.0.0, catering@^2.1.0, catering@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/catering/-/catering-2.1.1.tgz" + integrity sha512-K7Qy8O9p76sL3/3m7/zLKbRkyOlSZAgzEaLhyj2mXS8PsCud2Eo4hAb8aLtZqHh0QGqLcb9dlJSu6lHRVENm1w== + +cbor@^8.1.0: + version "8.1.0" + resolved "https://registry.npmjs.org/cbor/-/cbor-8.1.0.tgz" + integrity sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg== + dependencies: + nofilter "^3.1.0" + +cbor@^9.0.0: + version "9.0.2" + resolved "https://registry.yarnpkg.com/cbor/-/cbor-9.0.2.tgz#536b4f2d544411e70ec2b19a2453f10f83cd9fdb" + integrity sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ== + dependencies: + nofilter "^3.1.0" + +chai-as-promised@^7.1.1: + version "7.1.1" + resolved "https://registry.npmjs.org/chai-as-promised/-/chai-as-promised-7.1.1.tgz" + integrity sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA== + dependencies: + check-error "^1.0.2" + +chai@^4.3.6: + version "4.3.7" + resolved "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz" + integrity sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A== + dependencies: + assertion-error "^1.1.0" + check-error "^1.0.2" + deep-eql "^4.1.2" + get-func-name "^2.0.0" + loupe "^2.3.1" + pathval "^1.1.1" + type-detect "^4.0.5" + +chalk@^2.0.0, chalk@^2.1.0, chalk@^2.4.2: + version "2.4.2" + resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz" + integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== + dependencies: + ansi-styles "^3.2.1" + escape-string-regexp "^1.0.5" + supports-color "^5.3.0" + +chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.1, chalk@^4.1.2: + version "4.1.2" + resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +chardet@^0.7.0: + version "0.7.0" + resolved "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz" + integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA== + +"charenc@>= 0.0.1": + version "0.0.2" + resolved "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz" + integrity sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA== + +check-error@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz" + integrity sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA== + +chokidar@3.3.0: + version "3.3.0" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz" + integrity sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A== + dependencies: + anymatch "~3.1.1" + braces "~3.0.2" + glob-parent "~5.1.0" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.2.0" + optionalDependencies: + fsevents "~2.1.1" + +chokidar@3.5.3, chokidar@^3.4.0: + version "3.5.3" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz" + integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +chokidar@^1.6.0: + version "1.7.0" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz" + integrity sha512-mk8fAWcRUOxY7btlLtitj3A45jOwSAxH4tOFOoEGbVsl6cL6pPMWUy7dwZ/canfj3QEdP6FHSnf/l1c6/WkzVg== + dependencies: + anymatch "^1.3.0" + async-each "^1.0.0" + glob-parent "^2.0.0" + inherits "^2.0.1" + is-binary-path "^1.0.0" + is-glob "^2.0.0" + path-is-absolute "^1.0.0" + readdirp "^2.0.0" + optionalDependencies: + fsevents "^1.0.0" + +ci-info@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz" + integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ== + +ci-info@^3.1.0, ci-info@^3.2.0: + version "3.8.0" + resolved "https://registry.npmjs.org/ci-info/-/ci-info-3.8.0.tgz" + integrity sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw== + +cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz" + integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +class-utils@^0.3.5: + version "0.3.6" + resolved "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz" + integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg== + dependencies: + arr-union "^3.1.0" + define-property "^0.2.5" + isobject "^3.0.0" + static-extend "^0.1.1" + +classic-level@^1.2.0: + version "1.3.0" + resolved "https://registry.npmjs.org/classic-level/-/classic-level-1.3.0.tgz" + integrity sha512-iwFAJQYtqRTRM0F6L8h4JCt00ZSGdOyqh7yVrhhjrOpFhmBjNlRUey64MCiyo6UmQHMJ+No3c81nujPv+n9yrg== + dependencies: + abstract-level "^1.0.2" + catering "^2.1.0" + module-error "^1.0.1" + napi-macros "^2.2.2" + node-gyp-build "^4.3.0" + +clean-stack@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz" + integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A== + +clean-stack@^4.0.0: + version "4.2.0" + resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-4.2.0.tgz" + integrity sha512-LYv6XPxoyODi36Dp976riBtSY27VmFo+MKqEU9QCCWyTrdEPDog+RWA7xQWHi6Vbp61j5c4cdzzX1NidnwtUWg== + dependencies: + escape-string-regexp "5.0.0" + +cli-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz" + integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw== + dependencies: + restore-cursor "^3.1.0" + +cli-spinners@^2.5.0: + version "2.8.0" + resolved "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.8.0.tgz" + integrity sha512-/eG5sJcvEIwxcdYM86k5tPwn0MUzkX5YY3eImTGpJOZgVe4SdTMY14vQpcxgBzJ0wXwAYrS8E+c3uHeK4JNyzQ== + +cli-table3@^0.5.0: + version "0.5.1" + resolved "https://registry.npmjs.org/cli-table3/-/cli-table3-0.5.1.tgz" + integrity sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw== + dependencies: + object-assign "^4.1.0" + string-width "^2.1.1" + optionalDependencies: + colors "^1.1.2" + +cli-width@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/cli-width/-/cli-width-3.0.0.tgz" + integrity sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw== + +cliui@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz" + integrity sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA== + dependencies: + string-width "^3.1.0" + strip-ansi "^5.2.0" + wrap-ansi "^5.1.0" + +cliui@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/cliui/-/cliui-6.0.0.tgz" + integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.0" + wrap-ansi "^6.2.0" + +cliui@^7.0.2: + version "7.0.4" + resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz" + integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.0" + wrap-ansi "^7.0.0" + +cliui@^8.0.1: + version "8.0.1" + resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +clone@^1.0.2: + version "1.0.4" + resolved "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz" + integrity sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg== + +collection-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz" + integrity sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw== + dependencies: + map-visit "^1.0.0" + object-visit "^1.0.0" + +color-convert@^1.9.0: + version "1.9.3" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz" + integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== + dependencies: + color-name "1.1.3" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz" + integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw== + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +colors@1.4.0, colors@^1.1.2: + version "1.4.0" + resolved "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz" + integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA== + +combined-stream@^1.0.6, combined-stream@^1.0.8, combined-stream@~1.0.6: + version "1.0.8" + resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz" + integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== + dependencies: + delayed-stream "~1.0.0" + +command-exists@^1.2.8: + version "1.2.9" + resolved "https://registry.npmjs.org/command-exists/-/command-exists-1.2.9.tgz" + integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w== + +command-line-args@^5.1.1: + version "5.2.1" + resolved "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz" + integrity sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg== + dependencies: + array-back "^3.1.0" + find-replace "^3.0.0" + lodash.camelcase "^4.3.0" + typical "^4.0.0" + +command-line-usage@^6.1.0: + version "6.1.3" + resolved "https://registry.npmjs.org/command-line-usage/-/command-line-usage-6.1.3.tgz" + integrity sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw== + dependencies: + array-back "^4.0.2" + chalk "^2.4.2" + table-layout "^1.0.2" + typical "^5.2.0" + +commander@3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz" + integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow== + +commander@^10.0.0: + version "10.0.1" + resolved "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz" + integrity sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug== + +commander@^8.1.0: + version "8.3.0" + resolved "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz" + integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww== + +compare-versions@^6.0.0: + version "6.1.0" + resolved "https://registry.yarnpkg.com/compare-versions/-/compare-versions-6.1.0.tgz#3f2131e3ae93577df111dba133e6db876ffe127a" + integrity sha512-LNZQXhqUvqUTotpZ00qLSaify3b4VFD588aRr8MKFw4CMUr98ytzCW5wDH5qx/DEY5kCDXcbcRuCqL0szEf2tg== + +component-emitter@^1.2.1: + version "1.3.0" + resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz" + integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz" + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== + +concat-stream@^1.6.0, concat-stream@^1.6.2: + version "1.6.2" + resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz" + integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== + dependencies: + buffer-from "^1.0.0" + inherits "^2.0.3" + readable-stream "^2.2.2" + typedarray "^0.0.6" + +config-chain@^1.1.11: + version "1.1.13" + resolved "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz" + integrity sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ== + dependencies: + ini "^1.3.4" + proto-list "~1.2.1" + +cookie@^0.4.1: + version "0.4.2" + resolved "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz" + integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA== + +copy-descriptor@^0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz" + integrity sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw== + +core-js-pure@^3.0.1: + version "3.30.1" + resolved "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.30.1.tgz" + integrity sha512-nXBEVpmUnNRhz83cHd9JRQC52cTMcuXAmR56+9dSMpRdpeA4I1PX6yjmhd71Eyc/wXNsdBdUDIj1QTIeZpU5Tg== + +core-js@^2.4.0: + version "2.6.12" + resolved "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz" + integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ== + +core-util-is@1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz" + integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ== + +core-util-is@~1.0.0: + version "1.0.3" + resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== + +cosmiconfig@^8.0.0: + version "8.3.6" + resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz" + integrity sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA== + dependencies: + import-fresh "^3.3.0" + js-yaml "^4.1.0" + parse-json "^5.2.0" + path-type "^4.0.0" + +cpx@^1.5.0: + version "1.5.0" + resolved "https://registry.npmjs.org/cpx/-/cpx-1.5.0.tgz" + integrity sha512-jHTjZhsbg9xWgsP2vuNW2jnnzBX+p4T+vNI9Lbjzs1n4KhOfa22bQppiFYLsWQKd8TzmL5aSP/Me3yfsCwXbDA== + dependencies: + babel-runtime "^6.9.2" + chokidar "^1.6.0" + duplexer "^0.1.1" + glob "^7.0.5" + glob2base "^0.0.12" + minimatch "^3.0.2" + mkdirp "^0.5.1" + resolve "^1.1.7" + safe-buffer "^5.0.1" + shell-quote "^1.6.1" + subarg "^1.0.0" + +crc-32@^1.2.0: + version "1.2.2" + resolved "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz" + integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== + +create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz" + integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg== + dependencies: + cipher-base "^1.0.1" + inherits "^2.0.1" + md5.js "^1.3.4" + ripemd160 "^2.0.1" + sha.js "^2.4.0" + +create-hmac@^1.1.4, create-hmac@^1.1.7: + version "1.1.7" + resolved "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz" + integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg== + dependencies: + cipher-base "^1.0.3" + create-hash "^1.1.0" + inherits "^2.0.1" + ripemd160 "^2.0.0" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +create-require@^1.1.0: + version "1.1.1" + resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz" + integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== + +cross-spawn@^5.1.0: + version "5.1.0" + resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz" + integrity sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A== + dependencies: + lru-cache "^4.0.1" + shebang-command "^1.2.0" + which "^1.2.9" + +cross-spawn@^7.0.2: + version "7.0.3" + resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz" + integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +"crypt@>= 0.0.1": + version "0.0.2" + resolved "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz" + integrity sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow== + +csv-generate@^3.4.3: + version "3.4.3" + resolved "https://registry.npmjs.org/csv-generate/-/csv-generate-3.4.3.tgz" + integrity sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw== + +csv-parse@^4.16.3: + version "4.16.3" + resolved "https://registry.npmjs.org/csv-parse/-/csv-parse-4.16.3.tgz" + integrity sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg== + +csv-stringify@^5.6.5: + version "5.6.5" + resolved "https://registry.npmjs.org/csv-stringify/-/csv-stringify-5.6.5.tgz" + integrity sha512-PjiQ659aQ+fUTQqSrd1XEDnOr52jh30RBurfzkscaE2tPaFsDH5wOAHJiw8XAHphRknCwMUE9KRayc4K/NbO8A== + +csv@^5.5.3: + version "5.5.3" + resolved "https://registry.npmjs.org/csv/-/csv-5.5.3.tgz" + integrity sha512-QTaY0XjjhTQOdguARF0lGKm5/mEq9PD9/VhZZegHDIBq2tQwgNpHc3dneD4mGo2iJs+fTKv5Bp0fZ+BRuY3Z0g== + dependencies: + csv-generate "^3.4.3" + csv-parse "^4.16.3" + csv-stringify "^5.6.5" + stream-transform "^2.1.3" + +dashdash@^1.12.0: + version "1.14.1" + resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz" + integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g== + dependencies: + assert-plus "^1.0.0" + +data-view-buffer@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/data-view-buffer/-/data-view-buffer-1.0.1.tgz#8ea6326efec17a2e42620696e671d7d5a8bc66b2" + integrity sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +data-view-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/data-view-byte-length/-/data-view-byte-length-1.0.1.tgz#90721ca95ff280677eb793749fce1011347669e2" + integrity sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ== + dependencies: + call-bind "^1.0.7" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +data-view-byte-offset@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/data-view-byte-offset/-/data-view-byte-offset-1.0.0.tgz#5e0bbfb4828ed2d1b9b400cd8a7d119bca0ff18a" + integrity sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-data-view "^1.0.1" + +death@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/death/-/death-1.1.0.tgz" + integrity sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w== + +debug@3.2.6: + version "3.2.6" + resolved "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz" + integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ== + dependencies: + ms "^2.1.1" + +debug@4, debug@4.3.4, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.3, debug@^4.3.4: + version "4.3.4" + resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz" + integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== + dependencies: + ms "2.1.2" + +debug@^2.2.0, debug@^2.3.3: + version "2.6.9" + resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz" + integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== + dependencies: + ms "2.0.0" + +debug@^3.1.0, debug@^3.2.7: + version "3.2.7" + resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz" + integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ== + dependencies: + ms "^2.1.1" + +decamelize-keys@^1.1.0: + version "1.1.1" + resolved "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.1.tgz" + integrity sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg== + dependencies: + decamelize "^1.1.0" + map-obj "^1.0.0" + +decamelize@^1.1.0, decamelize@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz" + integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA== + +decamelize@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz" + integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ== + +decamelize@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-5.0.1.tgz" + integrity sha512-VfxadyCECXgQlkoEAjeghAr5gY3Hf+IKjKb+X8tGVDtveCjN+USwprd2q3QXBR9T1+x2DG0XZF5/w+7HAtSaXA== + +decode-uri-component@^0.2.0: + version "0.2.2" + resolved "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.2.tgz" + integrity sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ== + +decompress-response@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz" + integrity sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ== + dependencies: + mimic-response "^3.1.0" + +deep-eql@^4.0.1, deep-eql@^4.1.2: + version "4.1.3" + resolved "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz" + integrity sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw== + dependencies: + type-detect "^4.0.0" + +deep-extend@^0.6.0, deep-extend@~0.6.0: + version "0.6.0" + resolved "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz" + integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== + +deep-is@^0.1.3, deep-is@~0.1.3: + version "0.1.4" + resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz" + integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== + +defaults@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz" + integrity sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A== + dependencies: + clone "^1.0.2" + +defer-to-connect@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz" + integrity sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg== + +deferred-leveldown@~5.3.0: + version "5.3.0" + resolved "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-5.3.0.tgz" + integrity sha512-a59VOT+oDy7vtAbLRCZwWgxu2BaCfd5Hk7wxJd48ei7I+nsg8Orlb9CLG0PMZienk9BSUKgeAqkO2+Lw+1+Ukw== + dependencies: + abstract-leveldown "~6.2.1" + inherits "^2.0.3" + +define-data-property@^1.0.1, define-data-property@^1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/define-data-property/-/define-data-property-1.1.4.tgz#894dc141bb7d3060ae4366f6a0107e68fbe48c5e" + integrity sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A== + dependencies: + es-define-property "^1.0.0" + es-errors "^1.3.0" + gopd "^1.0.1" + +define-properties@^1.1.2, define-properties@^1.1.3, define-properties@^1.1.4: + version "1.2.0" + resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz" + integrity sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA== + dependencies: + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + +define-properties@^1.2.0, define-properties@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.1.tgz#10781cc616eb951a80a034bafcaa7377f6af2b6c" + integrity sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg== + dependencies: + define-data-property "^1.0.1" + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + +define-property@^0.2.5: + version "0.2.5" + resolved "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz" + integrity sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA== + dependencies: + is-descriptor "^0.1.0" + +define-property@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz" + integrity sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA== + dependencies: + is-descriptor "^1.0.0" + +define-property@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz" + integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ== + dependencies: + is-descriptor "^1.0.2" + isobject "^3.0.1" + +del-cli@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/del-cli/-/del-cli-5.0.0.tgz" + integrity sha512-rENFhUaYcjoMODwFhhlON+ogN7DoG+4+GFN+bsA1XeDt4w2OKQnQadFP1thHSAlK9FAtl88qgP66wOV+eFZZiQ== + dependencies: + del "^7.0.0" + meow "^10.1.3" + +del@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/del/-/del-7.0.0.tgz" + integrity sha512-tQbV/4u5WVB8HMJr08pgw0b6nG4RGt/tj+7Numvq+zqcvUFeMaIWWOUFltiU+6go8BSO2/ogsB4EasDaj0y68Q== + dependencies: + globby "^13.1.2" + graceful-fs "^4.2.10" + is-glob "^4.0.3" + is-path-cwd "^3.0.0" + is-path-inside "^4.0.0" + p-map "^5.5.0" + rimraf "^3.0.2" + slash "^4.0.0" + +delayed-stream@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz" + integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== + +delete-empty@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/delete-empty/-/delete-empty-3.0.0.tgz" + integrity sha512-ZUyiwo76W+DYnKsL3Kim6M/UOavPdBJgDYWOmuQhYaZvJH0AXAHbUNyEDtRbBra8wqqr686+63/0azfEk1ebUQ== + dependencies: + ansi-colors "^4.1.0" + minimist "^1.2.0" + path-starts-with "^2.0.0" + rimraf "^2.6.2" + +depd@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +detect-indent@^6.0.0: + version "6.1.0" + resolved "https://registry.npmjs.org/detect-indent/-/detect-indent-6.1.0.tgz" + integrity sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA== + +diff@3.5.0, diff@^3.1.0: + version "3.5.0" + resolved "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz" + integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA== + +diff@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz" + integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w== + +diff@^4.0.1: + version "4.0.2" + resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz" + integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== + +difflib@^0.2.4: + version "0.2.4" + resolved "https://registry.yarnpkg.com/difflib/-/difflib-0.2.4.tgz#b5e30361a6db023176d562892db85940a718f47e" + integrity sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w== + dependencies: + heap ">= 0.2.0" + +dir-glob@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz" + integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA== + dependencies: + path-type "^4.0.0" + +doctrine@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz" + integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw== + dependencies: + esutils "^2.0.2" + +doctrine@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz" + integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== + dependencies: + esutils "^2.0.2" + +dotenv@^16.0.0: + version "16.0.3" + resolved "https://registry.npmjs.org/dotenv/-/dotenv-16.0.3.tgz" + integrity sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ== + +dotenv@^16.1.4: + version "16.3.1" + resolved "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz" + integrity sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ== + +drbg.js@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz" + integrity sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g== + dependencies: + browserify-aes "^1.0.6" + create-hash "^1.1.2" + create-hmac "^1.1.4" + +duplexer@^0.1.1: + version "0.1.2" + resolved "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz" + integrity sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg== + +ecc-jsbn@~0.1.1: + version "0.1.2" + resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz" + integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw== + dependencies: + jsbn "~0.1.0" + safer-buffer "^2.1.0" + +elliptic@6.5.4, elliptic@^6.5.2, elliptic@^6.5.4: + version "6.5.4" + resolved "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz" + integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ== + dependencies: + bn.js "^4.11.9" + brorand "^1.1.0" + hash.js "^1.0.0" + hmac-drbg "^1.0.1" + inherits "^2.0.4" + minimalistic-assert "^1.0.1" + minimalistic-crypto-utils "^1.0.1" + +emittery@0.10.0: + version "0.10.0" + resolved "https://registry.npmjs.org/emittery/-/emittery-0.10.0.tgz" + integrity sha512-AGvFfs+d0JKCJQ4o01ASQLGPmSCxgfU9RFXvzPvZdjKK8oscynksuJhWrSTSw7j7Ep/sZct5b5ZhYCi8S/t0HQ== + +emoji-regex@^7.0.1: + version "7.0.3" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz" + integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +encoding-down@^6.3.0: + version "6.3.0" + resolved "https://registry.npmjs.org/encoding-down/-/encoding-down-6.3.0.tgz" + integrity sha512-QKrV0iKR6MZVJV08QY0wp1e7vF6QbhnbQhb07bwpEyuz4uZiZgPlEGdkCROuFkUwdxlFaiPIhjyarH1ee/3vhw== + dependencies: + abstract-leveldown "^6.2.1" + inherits "^2.0.3" + level-codec "^9.0.0" + level-errors "^2.0.0" + +enquirer@^2.3.0: + version "2.3.6" + resolved "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz" + integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg== + dependencies: + ansi-colors "^4.1.1" + +env-paths@^2.2.0: + version "2.2.1" + resolved "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz" + integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A== + +errno@~0.1.1: + version "0.1.8" + resolved "https://registry.npmjs.org/errno/-/errno-0.1.8.tgz" + integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A== + dependencies: + prr "~1.0.1" + +error-ex@^1.3.1: + version "1.3.2" + resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz" + integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== + dependencies: + is-arrayish "^0.2.1" + +es-abstract@^1.19.0, es-abstract@^1.20.4: + version "1.21.2" + resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz" + integrity sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg== + dependencies: + array-buffer-byte-length "^1.0.0" + available-typed-arrays "^1.0.5" + call-bind "^1.0.2" + es-set-tostringtag "^2.0.1" + es-to-primitive "^1.2.1" + function.prototype.name "^1.1.5" + get-intrinsic "^1.2.0" + get-symbol-description "^1.0.0" + globalthis "^1.0.3" + gopd "^1.0.1" + has "^1.0.3" + has-property-descriptors "^1.0.0" + has-proto "^1.0.1" + has-symbols "^1.0.3" + internal-slot "^1.0.5" + is-array-buffer "^3.0.2" + is-callable "^1.2.7" + is-negative-zero "^2.0.2" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.2" + is-string "^1.0.7" + is-typed-array "^1.1.10" + is-weakref "^1.0.2" + object-inspect "^1.12.3" + object-keys "^1.1.1" + object.assign "^4.1.4" + regexp.prototype.flags "^1.4.3" + safe-regex-test "^1.0.0" + string.prototype.trim "^1.2.7" + string.prototype.trimend "^1.0.6" + string.prototype.trimstart "^1.0.6" + typed-array-length "^1.0.4" + unbox-primitive "^1.0.2" + which-typed-array "^1.1.9" + +es-abstract@^1.22.1, es-abstract@^1.22.3, es-abstract@^1.23.0, es-abstract@^1.23.2: + version "1.23.3" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.23.3.tgz#8f0c5a35cd215312573c5a27c87dfd6c881a0aa0" + integrity sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A== + dependencies: + array-buffer-byte-length "^1.0.1" + arraybuffer.prototype.slice "^1.0.3" + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + data-view-buffer "^1.0.1" + data-view-byte-length "^1.0.1" + data-view-byte-offset "^1.0.0" + es-define-property "^1.0.0" + es-errors "^1.3.0" + es-object-atoms "^1.0.0" + es-set-tostringtag "^2.0.3" + es-to-primitive "^1.2.1" + function.prototype.name "^1.1.6" + get-intrinsic "^1.2.4" + get-symbol-description "^1.0.2" + globalthis "^1.0.3" + gopd "^1.0.1" + has-property-descriptors "^1.0.2" + has-proto "^1.0.3" + has-symbols "^1.0.3" + hasown "^2.0.2" + internal-slot "^1.0.7" + is-array-buffer "^3.0.4" + is-callable "^1.2.7" + is-data-view "^1.0.1" + is-negative-zero "^2.0.3" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.3" + is-string "^1.0.7" + is-typed-array "^1.1.13" + is-weakref "^1.0.2" + object-inspect "^1.13.1" + object-keys "^1.1.1" + object.assign "^4.1.5" + regexp.prototype.flags "^1.5.2" + safe-array-concat "^1.1.2" + safe-regex-test "^1.0.3" + string.prototype.trim "^1.2.9" + string.prototype.trimend "^1.0.8" + string.prototype.trimstart "^1.0.8" + typed-array-buffer "^1.0.2" + typed-array-byte-length "^1.0.1" + typed-array-byte-offset "^1.0.2" + typed-array-length "^1.0.6" + unbox-primitive "^1.0.2" + which-typed-array "^1.1.15" + +es-array-method-boxes-properly@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz" + integrity sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA== + +es-define-property@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-define-property/-/es-define-property-1.0.0.tgz#c7faefbdff8b2696cf5f46921edfb77cc4ba3845" + integrity sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ== + dependencies: + get-intrinsic "^1.2.4" + +es-errors@^1.2.1, es-errors@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/es-errors/-/es-errors-1.3.0.tgz#05f75a25dab98e4fb1dcd5e1472c0546d5057c8f" + integrity sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw== + +es-object-atoms@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-object-atoms/-/es-object-atoms-1.0.0.tgz#ddb55cd47ac2e240701260bc2a8e31ecb643d941" + integrity sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw== + dependencies: + es-errors "^1.3.0" + +es-set-tostringtag@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz" + integrity sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg== + dependencies: + get-intrinsic "^1.1.3" + has "^1.0.3" + has-tostringtag "^1.0.0" + +es-set-tostringtag@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/es-set-tostringtag/-/es-set-tostringtag-2.0.3.tgz#8bb60f0a440c2e4281962428438d58545af39777" + integrity sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ== + dependencies: + get-intrinsic "^1.2.4" + has-tostringtag "^1.0.2" + hasown "^2.0.1" + +es-shim-unscopables@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz" + integrity sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w== + dependencies: + has "^1.0.3" + +es-shim-unscopables@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/es-shim-unscopables/-/es-shim-unscopables-1.0.2.tgz#1f6942e71ecc7835ed1c8a83006d8771a63a3763" + integrity sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw== + dependencies: + hasown "^2.0.0" + +es-to-primitive@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz" + integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA== + dependencies: + is-callable "^1.1.4" + is-date-object "^1.0.1" + is-symbol "^1.0.2" + +escalade@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz" + integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== + +escape-string-regexp@1.0.5, escape-string-regexp@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz" + integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== + +escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz" + integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== + +escape-string-regexp@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz" + integrity sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw== + +escodegen@1.8.x: + version "1.8.1" + resolved "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz" + integrity sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A== + dependencies: + esprima "^2.7.1" + estraverse "^1.9.1" + esutils "^2.0.2" + optionator "^0.8.1" + optionalDependencies: + source-map "~0.2.0" + +eslint-config-prettier@^8.5.0: + version "8.8.0" + resolved "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-8.8.0.tgz" + integrity sha512-wLbQiFre3tdGgpDv67NQKnJuTlcUVYHas3k+DZCc2U2BadthoEY4B7hLPvAxaqdyOGCzuLfii2fqGph10va7oA== + +eslint-config-standard@^17.0.0: + version "17.0.0" + resolved "https://registry.npmjs.org/eslint-config-standard/-/eslint-config-standard-17.0.0.tgz" + integrity sha512-/2ks1GKyqSOkH7JFvXJicu0iMpoojkwB+f5Du/1SC0PtBL+s8v30k9njRZ21pm2drKYm2342jFnGWzttxPmZVg== + +eslint-import-resolver-node@^0.3.7: + version "0.3.7" + resolved "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.7.tgz" + integrity sha512-gozW2blMLJCeFpBwugLTGyvVjNoeo1knonXAcatC6bjPBZitotxdWf7Gimr25N4c0AAOo4eOUfaG82IJPDpqCA== + dependencies: + debug "^3.2.7" + is-core-module "^2.11.0" + resolve "^1.22.1" + +eslint-import-resolver-typescript@^2.7.1: + version "2.7.1" + resolved "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-2.7.1.tgz" + integrity sha512-00UbgGwV8bSgUv34igBDbTOtKhqoRMy9bFjNehT40bXg6585PNIct8HhXZ0SybqB9rWtXj9crcku8ndDn/gIqQ== + dependencies: + debug "^4.3.4" + glob "^7.2.0" + is-glob "^4.0.3" + resolve "^1.22.0" + tsconfig-paths "^3.14.1" + +eslint-module-utils@^2.7.4: + version "2.8.0" + resolved "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.8.0.tgz" + integrity sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw== + dependencies: + debug "^3.2.7" + +eslint-plugin-es@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/eslint-plugin-es/-/eslint-plugin-es-3.0.1.tgz" + integrity sha512-GUmAsJaN4Fc7Gbtl8uOBlayo2DqhwWvEzykMHSCZHU3XdJ+NSzzZcVhXh3VxX5icqQ+oQdIEawXX8xkR3mIFmQ== + dependencies: + eslint-utils "^2.0.0" + regexpp "^3.0.0" + +eslint-plugin-import@^2.26.0: + version "2.27.5" + resolved "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.27.5.tgz" + integrity sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow== + dependencies: + array-includes "^3.1.6" + array.prototype.flat "^1.3.1" + array.prototype.flatmap "^1.3.1" + debug "^3.2.7" + doctrine "^2.1.0" + eslint-import-resolver-node "^0.3.7" + eslint-module-utils "^2.7.4" + has "^1.0.3" + is-core-module "^2.11.0" + is-glob "^4.0.3" + minimatch "^3.1.2" + object.values "^1.1.6" + resolve "^1.22.1" + semver "^6.3.0" + tsconfig-paths "^3.14.1" + +eslint-plugin-node@^11.1.0: + version "11.1.0" + resolved "https://registry.npmjs.org/eslint-plugin-node/-/eslint-plugin-node-11.1.0.tgz" + integrity sha512-oUwtPJ1W0SKD0Tr+wqu92c5xuCeQqB3hSCHasn/ZgjFdA9iDGNkNf2Zi9ztY7X+hNuMib23LNGRm6+uN+KLE3g== + dependencies: + eslint-plugin-es "^3.0.0" + eslint-utils "^2.0.0" + ignore "^5.1.1" + minimatch "^3.0.4" + resolve "^1.10.1" + semver "^6.1.0" + +eslint-plugin-prettier@^4.0.0: + version "4.2.1" + resolved "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-4.2.1.tgz" + integrity sha512-f/0rXLXUt0oFYs8ra4w49wYZBG5GKZpAYsJSm6rnYL5uVDjd+zowwMwVZHnAjf4edNrKpCDYfXDgmRE/Ak7QyQ== + dependencies: + prettier-linter-helpers "^1.0.0" + +eslint-plugin-promise@^6.0.0: + version "6.1.1" + resolved "https://registry.npmjs.org/eslint-plugin-promise/-/eslint-plugin-promise-6.1.1.tgz" + integrity sha512-tjqWDwVZQo7UIPMeDReOpUgHCmCiH+ePnVT+5zVapL0uuHnegBUs2smM13CzOs2Xb5+MHMRFTs9v24yjba4Oig== + +eslint-plugin-simple-import-sort@7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/eslint-plugin-simple-import-sort/-/eslint-plugin-simple-import-sort-7.0.0.tgz" + integrity sha512-U3vEDB5zhYPNfxT5TYR7u01dboFZp+HNpnGhkDB2g/2E4wZ/g1Q9Ton8UwCLfRV9yAKyYqDh62oHOamvkFxsvw== + +eslint-plugin-sort-keys-fix@1.1.2: + version "1.1.2" + resolved "https://registry.npmjs.org/eslint-plugin-sort-keys-fix/-/eslint-plugin-sort-keys-fix-1.1.2.tgz" + integrity sha512-DNPHFGCA0/hZIsfODbeLZqaGY/+q3vgtshF85r+YWDNCQ2apd9PNs/zL6ttKm0nD1IFwvxyg3YOTI7FHl4unrw== + dependencies: + espree "^6.1.2" + esutils "^2.0.2" + natural-compare "^1.4.0" + requireindex "~1.2.0" + +eslint-plugin-typescript-sort-keys@2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/eslint-plugin-typescript-sort-keys/-/eslint-plugin-typescript-sort-keys-2.1.0.tgz" + integrity sha512-ET7ABypdz19m47QnKynzNfWPi4CTNQ5jQQC1X5d0gojIwblkbGiCa5IilsqzBTmqxZ0yXDqKBO/GBkBFQCOFsg== + dependencies: + "@typescript-eslint/experimental-utils" "^5.0.0" + json-schema "^0.4.0" + natural-compare-lite "^1.4.0" + +eslint-scope@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz" + integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== + dependencies: + esrecurse "^4.3.0" + estraverse "^4.1.1" + +eslint-scope@^7.1.1: + version "7.2.0" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.0.tgz" + integrity sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw== + dependencies: + esrecurse "^4.3.0" + estraverse "^5.2.0" + +eslint-utils@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz" + integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg== + dependencies: + eslint-visitor-keys "^1.1.0" + +eslint-visitor-keys@^1.1.0: + version "1.3.0" + resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz" + integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ== + +eslint-visitor-keys@^3.3.0, eslint-visitor-keys@^3.4.0: + version "3.4.0" + resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.0.tgz" + integrity sha512-HPpKPUBQcAsZOsHAFwTtIKcYlCje62XB7SEAcxjtmW6TD1WVpkS6i6/hOVtTZIl4zGj/mBqpFVGvaDneik+VoQ== + +eslint@^8.13.0: + version "8.38.0" + resolved "https://registry.npmjs.org/eslint/-/eslint-8.38.0.tgz" + integrity sha512-pIdsD2jwlUGf/U38Jv97t8lq6HpaU/G9NKbYmpWpZGw3LdTNhZLbJePqxOXGB5+JEKfOPU/XLxYxFh03nr1KTg== + dependencies: + "@eslint-community/eslint-utils" "^4.2.0" + "@eslint-community/regexpp" "^4.4.0" + "@eslint/eslintrc" "^2.0.2" + "@eslint/js" "8.38.0" + "@humanwhocodes/config-array" "^0.11.8" + "@humanwhocodes/module-importer" "^1.0.1" + "@nodelib/fs.walk" "^1.2.8" + ajv "^6.10.0" + chalk "^4.0.0" + cross-spawn "^7.0.2" + debug "^4.3.2" + doctrine "^3.0.0" + escape-string-regexp "^4.0.0" + eslint-scope "^7.1.1" + eslint-visitor-keys "^3.4.0" + espree "^9.5.1" + esquery "^1.4.2" + esutils "^2.0.2" + fast-deep-equal "^3.1.3" + file-entry-cache "^6.0.1" + find-up "^5.0.0" + glob-parent "^6.0.2" + globals "^13.19.0" + grapheme-splitter "^1.0.4" + ignore "^5.2.0" + import-fresh "^3.0.0" + imurmurhash "^0.1.4" + is-glob "^4.0.0" + is-path-inside "^3.0.3" + js-sdsl "^4.1.4" + js-yaml "^4.1.0" + json-stable-stringify-without-jsonify "^1.0.1" + levn "^0.4.1" + lodash.merge "^4.6.2" + minimatch "^3.1.2" + natural-compare "^1.4.0" + optionator "^0.9.1" + strip-ansi "^6.0.1" + strip-json-comments "^3.1.0" + text-table "^0.2.0" + +espree@^6.1.2: + version "6.2.1" + resolved "https://registry.npmjs.org/espree/-/espree-6.2.1.tgz" + integrity sha512-ysCxRQY3WaXJz9tdbWOwuWr5Y/XrPTGX9Kiz3yoUXwW0VZ4w30HTkQLaGx/+ttFjF8i+ACbArnB4ce68a9m5hw== + dependencies: + acorn "^7.1.1" + acorn-jsx "^5.2.0" + eslint-visitor-keys "^1.1.0" + +espree@^9.5.1: + version "9.5.1" + resolved "https://registry.npmjs.org/espree/-/espree-9.5.1.tgz" + integrity sha512-5yxtHSZXRSW5pvv3hAlXM5+/Oswi1AUFqBmbibKb5s6bp3rGIDkyXU6xCoyuuLhijr4SFwPrXRoZjz0AZDN9tg== + dependencies: + acorn "^8.8.0" + acorn-jsx "^5.3.2" + eslint-visitor-keys "^3.4.0" + +esprima@2.7.x, esprima@^2.7.1: + version "2.7.3" + resolved "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz" + integrity sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A== + +esprima@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +esquery@^1.4.2: + version "1.5.0" + resolved "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz" + integrity sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg== + dependencies: + estraverse "^5.1.0" + +esrecurse@^4.3.0: + version "4.3.0" + resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz" + integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== + dependencies: + estraverse "^5.2.0" + +estraverse@^1.9.1: + version "1.9.3" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz" + integrity sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA== + +estraverse@^4.1.1: + version "4.3.0" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz" + integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== + +estraverse@^5.1.0, estraverse@^5.2.0: + version "5.3.0" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz" + integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== + +esutils@^2.0.2: + version "2.0.3" + resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz" + integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== + +eth-gas-reporter@^0.2.25: + version "0.2.25" + resolved "https://registry.npmjs.org/eth-gas-reporter/-/eth-gas-reporter-0.2.25.tgz" + integrity sha512-1fRgyE4xUB8SoqLgN3eDfpDfwEfRxh2Sz1b7wzFbyQA+9TekMmvSjjoRu9SKcSVyK+vLkLIsVbJDsTWjw195OQ== + dependencies: + "@ethersproject/abi" "^5.0.0-beta.146" + "@solidity-parser/parser" "^0.14.0" + cli-table3 "^0.5.0" + colors "1.4.0" + ethereum-cryptography "^1.0.3" + ethers "^4.0.40" + fs-readdir-recursive "^1.1.0" + lodash "^4.17.14" + markdown-table "^1.1.3" + mocha "^7.1.1" + req-cwd "^2.0.0" + request "^2.88.0" + request-promise-native "^1.0.5" + sha1 "^1.1.1" + sync-request "^6.0.0" + +ethereum-bloom-filters@^1.0.6: + version "1.0.10" + resolved "https://registry.npmjs.org/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz" + integrity sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA== + dependencies: + js-sha3 "^0.8.0" + +ethereum-cryptography@0.1.3, ethereum-cryptography@^0.1.3: + version "0.1.3" + resolved "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz" + integrity sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ== + dependencies: + "@types/pbkdf2" "^3.0.0" + "@types/secp256k1" "^4.0.1" + blakejs "^1.1.0" + browserify-aes "^1.2.0" + bs58check "^2.1.2" + create-hash "^1.2.0" + create-hmac "^1.1.7" + hash.js "^1.1.7" + keccak "^3.0.0" + pbkdf2 "^3.0.17" + randombytes "^2.1.0" + safe-buffer "^5.1.2" + scrypt-js "^3.0.0" + secp256k1 "^4.0.1" + setimmediate "^1.0.5" + +ethereum-cryptography@^1.0.3: + version "1.2.0" + resolved "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.2.0.tgz" + integrity sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw== + dependencies: + "@noble/hashes" "1.2.0" + "@noble/secp256k1" "1.7.1" + "@scure/bip32" "1.1.5" + "@scure/bip39" "1.1.1" + +ethereum-cryptography@^2.0.0, ethereum-cryptography@^2.1.2: + version "2.2.0" + resolved "https://registry.yarnpkg.com/ethereum-cryptography/-/ethereum-cryptography-2.2.0.tgz#06e2d9c0d89f98ffc6a83818f55bf85afecd50dc" + integrity sha512-hsm9JhfytIf8QME/3B7j4bc8V+VdTU+Vas1aJlvIS96ffoNAosudXvGoEvWmc7QZYdkC8mrMJz9r0fcbw7GyCA== + dependencies: + "@noble/curves" "1.4.0" + "@noble/hashes" "1.4.0" + "@scure/bip32" "1.4.0" + "@scure/bip39" "1.3.0" + +ethereum-waffle@^4.0.9: + version "4.0.10" + resolved "https://registry.npmjs.org/ethereum-waffle/-/ethereum-waffle-4.0.10.tgz" + integrity sha512-iw9z1otq7qNkGDNcMoeNeLIATF9yKl1M8AIeu42ElfNBplq0e+5PeasQmm8ybY/elkZ1XyRO0JBQxQdVRb8bqQ== + dependencies: + "@ethereum-waffle/chai" "4.0.10" + "@ethereum-waffle/compiler" "4.0.3" + "@ethereum-waffle/mock-contract" "4.0.4" + "@ethereum-waffle/provider" "4.0.5" + solc "0.8.15" + typechain "^8.0.0" + +ethereumjs-abi@0.6.8, ethereumjs-abi@^0.6.8: + version "0.6.8" + resolved "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz" + integrity sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA== + dependencies: + bn.js "^4.11.8" + ethereumjs-util "^6.0.0" + +ethereumjs-util@7.1.3: + version "7.1.3" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.3.tgz" + integrity sha512-y+82tEbyASO0K0X1/SRhbJJoAlfcvq8JbrG4a5cjrOks7HS/36efU/0j2flxCPOUM++HFahk33kr/ZxyC4vNuw== + dependencies: + "@types/bn.js" "^5.1.0" + bn.js "^5.1.2" + create-hash "^1.1.2" + ethereum-cryptography "^0.1.3" + rlp "^2.2.4" + +ethereumjs-util@^6.0.0, ethereumjs-util@^6.2.1: + version "6.2.1" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz" + integrity sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw== + dependencies: + "@types/bn.js" "^4.11.3" + bn.js "^4.11.0" + create-hash "^1.1.2" + elliptic "^6.5.2" + ethereum-cryptography "^0.1.3" + ethjs-util "0.1.6" + rlp "^2.2.3" + +ethereumjs-util@^7.0.3, ethereumjs-util@^7.1.1, ethereumjs-util@^7.1.3, ethereumjs-util@^7.1.4, ethereumjs-util@^7.1.5: + version "7.1.5" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz" + integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg== + dependencies: + "@types/bn.js" "^5.1.0" + bn.js "^5.1.2" + create-hash "^1.1.2" + ethereum-cryptography "^0.1.3" + rlp "^2.2.4" + +ethereumjs-utils@^5.2.5: + version "5.2.5" + resolved "https://registry.npmjs.org/ethereumjs-utils/-/ethereumjs-utils-5.2.5.tgz" + integrity sha512-IkXL26c21kUKT5NQO4NFgeuYwXtqCD4dmiSWc/vivGNGwfYhEn2lYwmVIcbqVKS9yJfVEmrolWnQBuxEmTinIg== + dependencies: + bn.js "^4.11.0" + create-hash "^1.1.2" + ethjs-util "^0.1.3" + keccak "^1.0.2" + rlp "^2.0.0" + safe-buffer "^5.1.1" + secp256k1 "^3.0.1" + +ethers@5.6.8: + version "5.6.8" + resolved "https://registry.npmjs.org/ethers/-/ethers-5.6.8.tgz" + integrity sha512-YxIGaltAOdvBFPZwIkyHnXbW40f1r8mHUgapW6dxkO+6t7H6wY8POUn0Kbxrd/N7I4hHxyi7YCddMAH/wmho2w== + dependencies: + "@ethersproject/abi" "5.6.3" + "@ethersproject/abstract-provider" "5.6.1" + "@ethersproject/abstract-signer" "5.6.2" + "@ethersproject/address" "5.6.1" + "@ethersproject/base64" "5.6.1" + "@ethersproject/basex" "5.6.1" + "@ethersproject/bignumber" "5.6.2" + "@ethersproject/bytes" "5.6.1" + "@ethersproject/constants" "5.6.1" + "@ethersproject/contracts" "5.6.2" + "@ethersproject/hash" "5.6.1" + "@ethersproject/hdnode" "5.6.2" + "@ethersproject/json-wallets" "5.6.1" + "@ethersproject/keccak256" "5.6.1" + "@ethersproject/logger" "5.6.0" + "@ethersproject/networks" "5.6.3" + "@ethersproject/pbkdf2" "5.6.1" + "@ethersproject/properties" "5.6.0" + "@ethersproject/providers" "5.6.8" + "@ethersproject/random" "5.6.1" + "@ethersproject/rlp" "5.6.1" + "@ethersproject/sha2" "5.6.1" + "@ethersproject/signing-key" "5.6.2" + "@ethersproject/solidity" "5.6.1" + "@ethersproject/strings" "5.6.1" + "@ethersproject/transactions" "5.6.2" + "@ethersproject/units" "5.6.1" + "@ethersproject/wallet" "5.6.2" + "@ethersproject/web" "5.6.1" + "@ethersproject/wordlists" "5.6.1" + +ethers@^4.0.40: + version "4.0.49" + resolved "https://registry.npmjs.org/ethers/-/ethers-4.0.49.tgz" + integrity sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg== + dependencies: + aes-js "3.0.0" + bn.js "^4.11.9" + elliptic "6.5.4" + hash.js "1.1.3" + js-sha3 "0.5.7" + scrypt-js "2.0.4" + setimmediate "1.0.4" + uuid "2.0.1" + xmlhttprequest "1.8.0" + +ethers@^5.7.1: + version "5.7.2" + resolved "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz" + integrity sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg== + dependencies: + "@ethersproject/abi" "5.7.0" + "@ethersproject/abstract-provider" "5.7.0" + "@ethersproject/abstract-signer" "5.7.0" + "@ethersproject/address" "5.7.0" + "@ethersproject/base64" "5.7.0" + "@ethersproject/basex" "5.7.0" + "@ethersproject/bignumber" "5.7.0" + "@ethersproject/bytes" "5.7.0" + "@ethersproject/constants" "5.7.0" + "@ethersproject/contracts" "5.7.0" + "@ethersproject/hash" "5.7.0" + "@ethersproject/hdnode" "5.7.0" + "@ethersproject/json-wallets" "5.7.0" + "@ethersproject/keccak256" "5.7.0" + "@ethersproject/logger" "5.7.0" + "@ethersproject/networks" "5.7.1" + "@ethersproject/pbkdf2" "5.7.0" + "@ethersproject/properties" "5.7.0" + "@ethersproject/providers" "5.7.2" + "@ethersproject/random" "5.7.0" + "@ethersproject/rlp" "5.7.0" + "@ethersproject/sha2" "5.7.0" + "@ethersproject/signing-key" "5.7.0" + "@ethersproject/solidity" "5.7.0" + "@ethersproject/strings" "5.7.0" + "@ethersproject/transactions" "5.7.0" + "@ethersproject/units" "5.7.0" + "@ethersproject/wallet" "5.7.0" + "@ethersproject/web" "5.7.1" + "@ethersproject/wordlists" "5.7.0" + +ethjs-unit@0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz" + integrity sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw== + dependencies: + bn.js "4.11.6" + number-to-bn "1.7.0" + +ethjs-util@0.1.6, ethjs-util@^0.1.3, ethjs-util@^0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz" + integrity sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w== + dependencies: + is-hex-prefixed "1.0.0" + strip-hex-prefix "1.0.0" + +event-target-shim@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz" + integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== + +evp_bytestokey@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz" + integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA== + dependencies: + md5.js "^1.3.4" + safe-buffer "^5.1.1" + +expand-brackets@^0.1.4: + version "0.1.5" + resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz" + integrity sha512-hxx03P2dJxss6ceIeri9cmYOT4SRs3Zk3afZwWpOsRqLqprhTR8u++SlC+sFGsQr7WGFPdMF7Gjc1njDLDK6UA== + dependencies: + is-posix-bracket "^0.1.0" + +expand-brackets@^2.1.4: + version "2.1.4" + resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz" + integrity sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA== + dependencies: + debug "^2.3.3" + define-property "^0.2.5" + extend-shallow "^2.0.1" + posix-character-classes "^0.1.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +expand-range@^1.8.1: + version "1.8.2" + resolved "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz" + integrity sha512-AFASGfIlnIbkKPQwX1yHaDjFvh/1gyKJODme52V6IORh69uEYgZp0o9C+qsIGNVEiuuhQU0CSSl++Rlegg1qvA== + dependencies: + fill-range "^2.1.0" + +extend-shallow@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz" + integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug== + dependencies: + is-extendable "^0.1.0" + +extend-shallow@^3.0.0, extend-shallow@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz" + integrity sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q== + dependencies: + assign-symbols "^1.0.0" + is-extendable "^1.0.1" + +extend@~3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz" + integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== + +extendable-error@^0.1.5: + version "0.1.7" + resolved "https://registry.npmjs.org/extendable-error/-/extendable-error-0.1.7.tgz" + integrity sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg== + +external-editor@^3.0.3, external-editor@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz" + integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew== + dependencies: + chardet "^0.7.0" + iconv-lite "^0.4.24" + tmp "^0.0.33" + +extglob@^0.3.1: + version "0.3.2" + resolved "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz" + integrity sha512-1FOj1LOwn42TMrruOHGt18HemVnbwAmAak7krWk+wa93KXxGbK+2jpezm+ytJYDaBX0/SPLZFHKM7m+tKobWGg== + dependencies: + is-extglob "^1.0.0" + +extglob@^2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz" + integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw== + dependencies: + array-unique "^0.3.2" + define-property "^1.0.0" + expand-brackets "^2.1.4" + extend-shallow "^2.0.1" + fragment-cache "^0.2.1" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +extsprintf@1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz" + integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g== + +extsprintf@^1.2.0: + version "1.4.1" + resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz" + integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA== + +fast-base64-decode@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fast-base64-decode/-/fast-base64-decode-1.0.0.tgz#b434a0dd7d92b12b43f26819300d2dafb83ee418" + integrity sha512-qwaScUgUGBYeDNRnbc/KyllVU88Jk1pRHPStuF/lO7B0/RTRLj7U0lkdTAutlBblY08rwZDff6tNU9cjv6j//Q== + +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: + version "3.1.3" + resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-diff@^1.1.2, fast-diff@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz" + integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w== + +fast-glob@^3.0.3, fast-glob@^3.2.11, fast-glob@^3.2.9: + version "3.2.12" + resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz" + integrity sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.4" + +fast-json-stable-stringify@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz" + integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== + +fastq@^1.6.0: + version "1.15.0" + resolved "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz" + integrity sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw== + dependencies: + reusify "^1.0.4" + +figures@^3.0.0: + version "3.2.0" + resolved "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz" + integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg== + dependencies: + escape-string-regexp "^1.0.5" + +file-entry-cache@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz" + integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== + dependencies: + flat-cache "^3.0.4" + +file-uri-to-path@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz" + integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== + +filename-regex@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz" + integrity sha512-BTCqyBaWBTsauvnHiE8i562+EdJj+oUpkqWp2R1iCoR8f6oo8STRu3of7WJJ0TqWtxN50a5YFpzYK4Jj9esYfQ== + +fill-range@^2.1.0: + version "2.2.4" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz" + integrity sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q== + dependencies: + is-number "^2.1.0" + isobject "^2.0.0" + randomatic "^3.0.0" + repeat-element "^1.1.2" + repeat-string "^1.5.2" + +fill-range@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz" + integrity sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ== + dependencies: + extend-shallow "^2.0.1" + is-number "^3.0.0" + repeat-string "^1.6.1" + to-regex-range "^2.1.0" + +fill-range@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz" + integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== + dependencies: + to-regex-range "^5.0.1" + +find-index@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/find-index/-/find-index-0.1.1.tgz" + integrity sha512-uJ5vWrfBKMcE6y2Z8834dwEZj9mNGxYa3t3I53OwFeuZ8D9oc2E5zcsrkuhX6h4iYrjhiv0T3szQmxlAV9uxDg== + +find-replace@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz" + integrity sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ== + dependencies: + array-back "^3.0.1" + +find-up@3.0.0, find-up@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz" + integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg== + dependencies: + locate-path "^3.0.0" + +find-up@5.0.0, find-up@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz" + integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== + dependencies: + locate-path "^6.0.0" + path-exists "^4.0.0" + +find-up@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz" + integrity sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ== + dependencies: + locate-path "^2.0.0" + +find-up@^4.0.0, find-up@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz" + integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== + dependencies: + locate-path "^5.0.0" + path-exists "^4.0.0" + +find-yarn-workspace-root2@1.2.16: + version "1.2.16" + resolved "https://registry.npmjs.org/find-yarn-workspace-root2/-/find-yarn-workspace-root2-1.2.16.tgz" + integrity sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA== + dependencies: + micromatch "^4.0.2" + pkg-dir "^4.2.0" + +flat-cache@^3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz" + integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== + dependencies: + flatted "^3.1.0" + rimraf "^3.0.2" + +flat@^4.1.0: + version "4.1.1" + resolved "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz" + integrity sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA== + dependencies: + is-buffer "~2.0.3" + +flat@^5.0.2: + version "5.0.2" + resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz" + integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ== + +flatted@^3.1.0: + version "3.2.7" + resolved "https://registry.npmjs.org/flatted/-/flatted-3.2.7.tgz" + integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ== + +follow-redirects@^1.12.1: + version "1.15.2" + resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz" + integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA== + +follow-redirects@^1.14.0, follow-redirects@^1.15.6: + version "1.15.6" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.6.tgz#7f815c0cda4249c74ff09e95ef97c23b5fd0399b" + integrity sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA== + +follow-redirects@^1.15.4: + version "1.15.4" + resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz" + integrity sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw== + +for-each@^0.3.3: + version "0.3.3" + resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz" + integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw== + dependencies: + is-callable "^1.1.3" + +for-in@^1.0.1, for-in@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz" + integrity sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ== + +for-own@^0.1.4: + version "0.1.5" + resolved "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz" + integrity sha512-SKmowqGTJoPzLO1T0BBJpkfp3EMacCMOuH40hOUbrbzElVktk4DioXVM99QkLCyKoiuOmyjgcWMpVz2xjE7LZw== + dependencies: + for-in "^1.0.1" + +forever-agent@~0.6.1: + version "0.6.1" + resolved "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz" + integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw== + +form-data-encoder@^2.1.2: + version "2.1.4" + resolved "https://registry.npmjs.org/form-data-encoder/-/form-data-encoder-2.1.4.tgz" + integrity sha512-yDYSgNMraqvnxiEXO4hi88+YZxaHC6QKzb5N84iRCTDeRO7ZALpir/lVmf/uXUhnwUr2O4HU8s/n6x+yNjQkHw== + +form-data@^2.2.0: + version "2.5.1" + resolved "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz" + integrity sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +form-data@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/form-data/-/form-data-3.0.1.tgz" + integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.8" + mime-types "^2.1.12" + +form-data@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz" + integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.8" + mime-types "^2.1.12" + +form-data@~2.3.2: + version "2.3.3" + resolved "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz" + integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +fp-ts@1.19.3: + version "1.19.3" + resolved "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.3.tgz" + integrity sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg== + +fp-ts@^1.0.0: + version "1.19.5" + resolved "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.5.tgz" + integrity sha512-wDNqTimnzs8QqpldiId9OavWK2NptormjXnRJTQecNjzwfyp6P/8s/zG8e4h3ja3oqkKaY72UlTjQYt/1yXf9A== + +fragment-cache@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz" + integrity sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA== + dependencies: + map-cache "^0.2.2" + +fs-extra@^0.30.0: + version "0.30.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz" + integrity sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA== + dependencies: + graceful-fs "^4.1.2" + jsonfile "^2.1.0" + klaw "^1.0.0" + path-is-absolute "^1.0.0" + rimraf "^2.2.8" + +fs-extra@^7.0.0, fs-extra@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz" + integrity sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw== + dependencies: + graceful-fs "^4.1.2" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs-extra@^8.1.0: + version "8.1.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz" + integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g== + dependencies: + graceful-fs "^4.2.0" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs-extra@^9.1.0: + version "9.1.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz" + integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ== + dependencies: + at-least-node "^1.0.0" + graceful-fs "^4.2.0" + jsonfile "^6.0.1" + universalify "^2.0.0" + +fs-readdir-recursive@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz" + integrity sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA== + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz" + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== + +fsevents@^1.0.0: + version "1.2.13" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz" + integrity sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw== + dependencies: + bindings "^1.5.0" + nan "^2.12.1" + +fsevents@~2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz" + integrity sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ== + +fsevents@~2.3.2: + version "2.3.2" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz" + integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== + +function-bind@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz" + integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== + +function-bind@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c" + integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA== + +function.prototype.name@^1.1.5: + version "1.1.5" + resolved "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz" + integrity sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.0" + functions-have-names "^1.2.2" + +function.prototype.name@^1.1.6: + version "1.1.6" + resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.6.tgz#cdf315b7d90ee77a4c6ee216c3c3362da07533fd" + integrity sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg== + dependencies: + call-bind "^1.0.2" + define-properties "^1.2.0" + es-abstract "^1.22.1" + functions-have-names "^1.2.3" + +functional-red-black-tree@^1.0.1, functional-red-black-tree@~1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz" + integrity sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g== + +functions-have-names@^1.2.2, functions-have-names@^1.2.3: + version "1.2.3" + resolved "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz" + integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== + +ganache@7.4.3: + version "7.4.3" + resolved "https://registry.npmjs.org/ganache/-/ganache-7.4.3.tgz" + integrity sha512-RpEDUiCkqbouyE7+NMXG26ynZ+7sGiODU84Kz+FVoXUnQ4qQM4M8wif3Y4qUCt+D/eM1RVeGq0my62FPD6Y1KA== + dependencies: + "@trufflesuite/bigint-buffer" "1.1.10" + "@types/bn.js" "^5.1.0" + "@types/lru-cache" "5.1.1" + "@types/seedrandom" "3.0.1" + emittery "0.10.0" + keccak "3.0.2" + leveldown "6.1.0" + secp256k1 "4.0.3" + optionalDependencies: + bufferutil "4.0.5" + utf-8-validate "5.0.7" + +get-caller-file@^2.0.1, get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-func-name@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz" + integrity sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig== + +get-intrinsic@^1.0.2, get-intrinsic@^1.1.1, get-intrinsic@^1.1.3, get-intrinsic@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz" + integrity sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q== + dependencies: + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.3" + +get-intrinsic@^1.2.1, get-intrinsic@^1.2.3, get-intrinsic@^1.2.4: + version "1.2.4" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.4.tgz#e385f5a4b5227d449c3eabbad05494ef0abbeadd" + integrity sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ== + dependencies: + es-errors "^1.3.0" + function-bind "^1.1.2" + has-proto "^1.0.1" + has-symbols "^1.0.3" + hasown "^2.0.0" + +get-port@^3.1.0: + version "3.2.0" + resolved "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz" + integrity sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg== + +get-stream@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz" + integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== + +get-symbol-description@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz" + integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.1.1" + +get-symbol-description@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.2.tgz#533744d5aa20aca4e079c8e5daf7fd44202821f5" + integrity sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg== + dependencies: + call-bind "^1.0.5" + es-errors "^1.3.0" + get-intrinsic "^1.2.4" + +get-value@^2.0.3, get-value@^2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz" + integrity sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA== + +getpass@^0.1.1: + version "0.1.7" + resolved "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz" + integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng== + dependencies: + assert-plus "^1.0.0" + +ghost-testrpc@^0.0.2: + version "0.0.2" + resolved "https://registry.npmjs.org/ghost-testrpc/-/ghost-testrpc-0.0.2.tgz" + integrity sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ== + dependencies: + chalk "^2.4.2" + node-emoji "^1.10.0" + +glob-base@^0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz" + integrity sha512-ab1S1g1EbO7YzauaJLkgLp7DZVAqj9M/dvKlTt8DkXA2tiOIcSMrlVI2J1RZyB5iJVccEscjGn+kpOG9788MHA== + dependencies: + glob-parent "^2.0.0" + is-glob "^2.0.0" + +glob-parent@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz" + integrity sha512-JDYOvfxio/t42HKdxkAYaCiBN7oYiuxykOxKxdaUW5Qn0zaYN3gRQWolrwdnf0shM9/EP0ebuuTmyoXNr1cC5w== + dependencies: + is-glob "^2.0.0" + +glob-parent@^5.1.2, glob-parent@~5.1.0, glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob-parent@^6.0.2: + version "6.0.2" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz" + integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A== + dependencies: + is-glob "^4.0.3" + +glob2base@^0.0.12: + version "0.0.12" + resolved "https://registry.npmjs.org/glob2base/-/glob2base-0.0.12.tgz" + integrity sha512-ZyqlgowMbfj2NPjxaZZ/EtsXlOch28FRXgMd64vqZWk1bT9+wvSRLYD1om9M7QfQru51zJPAT17qXm4/zd+9QA== + dependencies: + find-index "^0.1.1" + +glob@7.1.3: + version "7.1.3" + resolved "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz" + integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@7.1.7: + version "7.1.7" + resolved "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz" + integrity sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@7.2.0: + version "7.2.0" + resolved "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz" + integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^5.0.15: + version "5.0.15" + resolved "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz" + integrity sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA== + dependencies: + inflight "^1.0.4" + inherits "2" + minimatch "2 || 3" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^7.0.0, glob@^7.0.5, glob@^7.1.3, glob@^7.2.0: + version "7.2.3" + resolved "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.1.1" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^8.0.3: + version "8.1.0" + resolved "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz" + integrity sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^5.0.1" + once "^1.3.0" + +global-modules@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz" + integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A== + dependencies: + global-prefix "^3.0.0" + +global-prefix@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz" + integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg== + dependencies: + ini "^1.3.5" + kind-of "^6.0.2" + which "^1.3.1" + +globals@^13.19.0: + version "13.20.0" + resolved "https://registry.npmjs.org/globals/-/globals-13.20.0.tgz" + integrity sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ== + dependencies: + type-fest "^0.20.2" + +globalthis@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz" + integrity sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA== + dependencies: + define-properties "^1.1.3" + +globby@^10.0.1: + version "10.0.2" + resolved "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz" + integrity sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg== + dependencies: + "@types/glob" "^7.1.1" + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.0.3" + glob "^7.1.3" + ignore "^5.1.1" + merge2 "^1.2.3" + slash "^3.0.0" + +globby@^11.0.0, globby@^11.1.0: + version "11.1.0" + resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz" + integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g== + dependencies: + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.2.9" + ignore "^5.2.0" + merge2 "^1.4.1" + slash "^3.0.0" + +globby@^13.1.2: + version "13.2.0" + resolved "https://registry.npmjs.org/globby/-/globby-13.2.0.tgz" + integrity sha512-jWsQfayf13NvqKUIL3Ta+CIqMnvlaIDFveWE/dpOZ9+3AMEJozsxDvKA02zync9UuvOM8rOXzsD5GqKP4OnWPQ== + dependencies: + dir-glob "^3.0.1" + fast-glob "^3.2.11" + ignore "^5.2.0" + merge2 "^1.4.1" + slash "^4.0.0" + +gopd@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz" + integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA== + dependencies: + get-intrinsic "^1.1.3" + +got@^12.1.0: + version "12.6.1" + resolved "https://registry.npmjs.org/got/-/got-12.6.1.tgz" + integrity sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ== + dependencies: + "@sindresorhus/is" "^5.2.0" + "@szmarczak/http-timer" "^5.0.1" + cacheable-lookup "^7.0.0" + cacheable-request "^10.2.8" + decompress-response "^6.0.0" + form-data-encoder "^2.1.2" + get-stream "^6.0.1" + http2-wrapper "^2.1.10" + lowercase-keys "^3.0.0" + p-cancelable "^3.0.0" + responselike "^3.0.0" + +graceful-fs@4.2.10: + version "4.2.10" + resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz" + integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== + +graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.5, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4: + version "4.2.11" + resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz" + integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== + +grapheme-splitter@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/grapheme-splitter/-/grapheme-splitter-1.0.4.tgz" + integrity sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ== + +growl@1.10.5: + version "1.10.5" + resolved "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz" + integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA== + +handlebars@^4.0.1: + version "4.7.7" + resolved "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz" + integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA== + dependencies: + minimist "^1.2.5" + neo-async "^2.6.0" + source-map "^0.6.1" + wordwrap "^1.0.0" + optionalDependencies: + uglify-js "^3.1.4" + +har-schema@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz" + integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q== + +har-validator@~5.1.3: + version "5.1.5" + resolved "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz" + integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w== + dependencies: + ajv "^6.12.3" + har-schema "^2.0.0" + +hard-rejection@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz" + integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA== + +hardhat-abi-exporter@^2.10.1: + version "2.10.1" + resolved "https://registry.npmjs.org/hardhat-abi-exporter/-/hardhat-abi-exporter-2.10.1.tgz" + integrity sha512-X8GRxUTtebMAd2k4fcPyVnCdPa6dYK4lBsrwzKP5yiSq4i+WadWPIumaLfce53TUf/o2TnLpLOduyO1ylE2NHQ== + dependencies: + "@ethersproject/abi" "^5.5.0" + delete-empty "^3.0.0" + +hardhat-gas-reporter@^1.0.9: + version "1.0.9" + resolved "https://registry.npmjs.org/hardhat-gas-reporter/-/hardhat-gas-reporter-1.0.9.tgz" + integrity sha512-INN26G3EW43adGKBNzYWOlI3+rlLnasXTwW79YNnUhXPDa+yHESgt639dJEs37gCjhkbNKcRRJnomXEuMFBXJg== + dependencies: + array-uniq "1.0.3" + eth-gas-reporter "^0.2.25" + sha1 "^1.1.1" + +hardhat@^2.13.1: + version "2.13.1" + resolved "https://registry.npmjs.org/hardhat/-/hardhat-2.13.1.tgz" + integrity sha512-ZZL7LQxHmbw4JQJsiEv2qE35nbR+isr2sIdtgZVPp0+zWqRkpr1OT7gmvhCNYfjpEPyfjZIxWriQWlphJhVPLQ== + dependencies: + "@ethersproject/abi" "^5.1.2" + "@metamask/eth-sig-util" "^4.0.0" + "@nomicfoundation/ethereumjs-block" "5.0.0" + "@nomicfoundation/ethereumjs-blockchain" "7.0.0" + "@nomicfoundation/ethereumjs-common" "4.0.0" + "@nomicfoundation/ethereumjs-evm" "2.0.0" + "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-statemanager" "2.0.0" + "@nomicfoundation/ethereumjs-trie" "6.0.0" + "@nomicfoundation/ethereumjs-tx" "5.0.0" + "@nomicfoundation/ethereumjs-util" "9.0.0" + "@nomicfoundation/ethereumjs-vm" "7.0.0" + "@nomicfoundation/solidity-analyzer" "^0.1.0" + "@sentry/node" "^5.18.1" + "@types/bn.js" "^5.1.0" + "@types/lru-cache" "^5.1.0" + abort-controller "^3.0.0" + adm-zip "^0.4.16" + aggregate-error "^3.0.0" + ansi-escapes "^4.3.0" + chalk "^2.4.2" + chokidar "^3.4.0" + ci-info "^2.0.0" + debug "^4.1.1" + enquirer "^2.3.0" + env-paths "^2.2.0" + ethereum-cryptography "^1.0.3" + ethereumjs-abi "^0.6.8" + find-up "^2.1.0" + fp-ts "1.19.3" + fs-extra "^7.0.1" + glob "7.2.0" + immutable "^4.0.0-rc.12" + io-ts "1.10.4" + keccak "^3.0.2" + lodash "^4.17.11" + mnemonist "^0.38.0" + mocha "^10.0.0" + p-map "^4.0.0" + qs "^6.7.0" + raw-body "^2.4.1" + resolve "1.17.0" + semver "^6.3.0" + solc "0.7.3" + source-map-support "^0.5.13" + stacktrace-parser "^0.1.10" + tsort "0.0.1" + undici "^5.14.0" + uuid "^8.3.2" + ws "^7.4.6" + +has-bigints@^1.0.1, has-bigints@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz" + integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ== + +has-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz" + integrity sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA== + +has-flag@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz" + integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw== + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-property-descriptors@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz" + integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ== + dependencies: + get-intrinsic "^1.1.1" + +has-property-descriptors@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz#963ed7d071dc7bf5f084c5bfbe0d1b6222586854" + integrity sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg== + dependencies: + es-define-property "^1.0.0" + +has-proto@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz" + integrity sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg== + +has-proto@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-proto/-/has-proto-1.0.3.tgz#b31ddfe9b0e6e9914536a6ab286426d0214f77fd" + integrity sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q== + +has-symbols@^1.0.0, has-symbols@^1.0.2, has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== + +has-tostringtag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz" + integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ== + dependencies: + has-symbols "^1.0.2" + +has-tostringtag@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.2.tgz#2cdc42d40bef2e5b4eeab7c01a73c54ce7ab5abc" + integrity sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw== + dependencies: + has-symbols "^1.0.3" + +has-value@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz" + integrity sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q== + dependencies: + get-value "^2.0.3" + has-values "^0.1.4" + isobject "^2.0.0" + +has-value@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz" + integrity sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw== + dependencies: + get-value "^2.0.6" + has-values "^1.0.0" + isobject "^3.0.0" + +has-values@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz" + integrity sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ== + +has-values@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz" + integrity sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ== + dependencies: + is-number "^3.0.0" + kind-of "^4.0.0" + +has@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz" + integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== + dependencies: + function-bind "^1.1.1" + +hash-base@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz" + integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA== + dependencies: + inherits "^2.0.4" + readable-stream "^3.6.0" + safe-buffer "^5.2.0" + +hash.js@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz" + integrity sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA== + dependencies: + inherits "^2.0.3" + minimalistic-assert "^1.0.0" + +hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7: + version "1.1.7" + resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz" + integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA== + dependencies: + inherits "^2.0.3" + minimalistic-assert "^1.0.1" + +hasown@^2.0.0, hasown@^2.0.1, hasown@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003" + integrity sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ== + dependencies: + function-bind "^1.1.2" + +he@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz" + integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== + +"heap@>= 0.2.0": + version "0.2.7" + resolved "https://registry.yarnpkg.com/heap/-/heap-0.2.7.tgz#1e6adf711d3f27ce35a81fe3b7bd576c2260a8fc" + integrity sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg== + +hmac-drbg@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz" + integrity sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg== + dependencies: + hash.js "^1.0.3" + minimalistic-assert "^1.0.0" + minimalistic-crypto-utils "^1.0.1" + +hosted-git-info@^2.1.4, hosted-git-info@^2.6.0: + version "2.8.9" + resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz" + integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw== + +hosted-git-info@^4.0.1: + version "4.1.0" + resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz" + integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA== + dependencies: + lru-cache "^6.0.0" + +http-basic@^8.1.1: + version "8.1.3" + resolved "https://registry.npmjs.org/http-basic/-/http-basic-8.1.3.tgz" + integrity sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw== + dependencies: + caseless "^0.12.0" + concat-stream "^1.6.2" + http-response-object "^3.0.1" + parse-cache-control "^1.0.1" + +http-cache-semantics@^4.1.1: + version "4.1.1" + resolved "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz" + integrity sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ== + +http-errors@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== + dependencies: + depd "2.0.0" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses "2.0.1" + toidentifier "1.0.1" + +http-response-object@^3.0.1: + version "3.0.2" + resolved "https://registry.npmjs.org/http-response-object/-/http-response-object-3.0.2.tgz" + integrity sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA== + dependencies: + "@types/node" "^10.0.3" + +http-signature@~1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz" + integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ== + dependencies: + assert-plus "^1.0.0" + jsprim "^1.2.2" + sshpk "^1.7.0" + +http2-wrapper@^2.1.10: + version "2.2.1" + resolved "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-2.2.1.tgz" + integrity sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ== + dependencies: + quick-lru "^5.1.1" + resolve-alpn "^1.2.0" + +https-proxy-agent@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz" + integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA== + dependencies: + agent-base "6" + debug "4" + +human-id@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/human-id/-/human-id-1.0.2.tgz" + integrity sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw== + +iconv-lite@0.4.24, iconv-lite@^0.4.24: + version "0.4.24" + resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz" + integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== + dependencies: + safer-buffer ">= 2.1.2 < 3" + +ieee754@^1.1.13, ieee754@^1.1.4, ieee754@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" + integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== + +ignore@^5.1.1, ignore@^5.2.0, ignore@^5.2.4: + version "5.2.4" + resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz" + integrity sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ== + +immediate@^3.2.3: + version "3.3.0" + resolved "https://registry.npmjs.org/immediate/-/immediate-3.3.0.tgz" + integrity sha512-HR7EVodfFUdQCTIeySw+WDRFJlPcLOJbXfwwZ7Oom6tjsvZ3bOkCDJHehQC3nxJrv7+f9XecwazynjU8e4Vw3Q== + +immediate@~3.2.3: + version "3.2.3" + resolved "https://registry.npmjs.org/immediate/-/immediate-3.2.3.tgz" + integrity sha512-RrGCXRm/fRVqMIhqXrGEX9rRADavPiDFSoMb/k64i9XMk8uH4r/Omi5Ctierj6XzNecwDbO4WuFbDD1zmpl3Tg== + +immutable@^4.0.0-rc.12: + version "4.3.0" + resolved "https://registry.npmjs.org/immutable/-/immutable-4.3.0.tgz" + integrity sha512-0AOCmOip+xgJwEVTQj1EfiDDOkPmuyllDuTuEX+DDXUgapLAsBIfkg3sxCYyCEA8mQqZrrxPUGjcOQ2JS3WLkg== + +import-fresh@^3.0.0, import-fresh@^3.2.1, import-fresh@^3.3.0: + version "3.3.0" + resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz" + integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== + dependencies: + parent-module "^1.0.0" + resolve-from "^4.0.0" + +imurmurhash@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz" + integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== + +indent-string@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz" + integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg== + +indent-string@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz" + integrity sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg== + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz" + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3: + version "2.0.4" + resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ini@^1.3.4, ini@^1.3.5, ini@~1.3.0: + version "1.3.8" + resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz" + integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== + +inquirer@^8.2.4: + version "8.2.5" + resolved "https://registry.npmjs.org/inquirer/-/inquirer-8.2.5.tgz" + integrity sha512-QAgPDQMEgrDssk1XiwwHoOGYF9BAbUcc1+j+FhEvaOt8/cKRqyLn0U5qA6F74fGhTMGxf92pOvPBeh29jQJDTQ== + dependencies: + ansi-escapes "^4.2.1" + chalk "^4.1.1" + cli-cursor "^3.1.0" + cli-width "^3.0.0" + external-editor "^3.0.3" + figures "^3.0.0" + lodash "^4.17.21" + mute-stream "0.0.8" + ora "^5.4.1" + run-async "^2.4.0" + rxjs "^7.5.5" + string-width "^4.1.0" + strip-ansi "^6.0.0" + through "^2.3.6" + wrap-ansi "^7.0.0" + +internal-slot@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz" + integrity sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ== + dependencies: + get-intrinsic "^1.2.0" + has "^1.0.3" + side-channel "^1.0.4" + +internal-slot@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.7.tgz#c06dcca3ed874249881007b0a5523b172a190802" + integrity sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g== + dependencies: + es-errors "^1.3.0" + hasown "^2.0.0" + side-channel "^1.0.4" + +interpret@^1.0.0: + version "1.4.0" + resolved "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz" + integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== + +io-ts@1.10.4: + version "1.10.4" + resolved "https://registry.npmjs.org/io-ts/-/io-ts-1.10.4.tgz" + integrity sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g== + dependencies: + fp-ts "^1.0.0" + +is-accessor-descriptor@^0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz" + integrity sha512-e1BM1qnDbMRG3ll2U9dSK0UMHuWOs3pY3AtcFsmvwPtKL3MML/Q86i+GilLfvqEs4GW+ExB91tQ3Ig9noDIZ+A== + dependencies: + kind-of "^3.0.2" + +is-accessor-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz" + integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ== + dependencies: + kind-of "^6.0.0" + +is-array-buffer@^3.0.1, is-array-buffer@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz" + integrity sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.2.0" + is-typed-array "^1.1.10" + +is-array-buffer@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/is-array-buffer/-/is-array-buffer-3.0.4.tgz#7a1f92b3d61edd2bc65d24f130530ea93d7fae98" + integrity sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.2.1" + +is-arrayish@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz" + integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== + +is-bigint@^1.0.1: + version "1.0.4" + resolved "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz" + integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg== + dependencies: + has-bigints "^1.0.1" + +is-binary-path@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz" + integrity sha512-9fRVlXc0uCxEDj1nQzaWONSpbTfx0FmJfzHF7pwlI8DkWGoHBBea4Pg5Ky0ojwwxQmnSifgbKkI06Qv0Ljgj+Q== + dependencies: + binary-extensions "^1.0.0" + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-boolean-object@^1.1.0: + version "1.1.2" + resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz" + integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-buffer@^1.1.5: + version "1.1.6" + resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz" + integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w== + +is-buffer@^2.0.5, is-buffer@~2.0.3: + version "2.0.5" + resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz" + integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ== + +is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7: + version "1.2.7" + resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz" + integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA== + +is-ci@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/is-ci/-/is-ci-3.0.1.tgz" + integrity sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ== + dependencies: + ci-info "^3.2.0" + +is-core-module@^2.11.0, is-core-module@^2.12.0: + version "2.12.0" + resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.12.0.tgz" + integrity sha512-RECHCBCd/viahWmwj6enj19sKbHfJrddi/6cBDsNTKbNq0f7VeaUkBo60BqzvPqo/W54ChS62Z5qyun7cfOMqQ== + dependencies: + has "^1.0.3" + +is-core-module@^2.5.0: + version "2.12.1" + resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.12.1.tgz" + integrity sha512-Q4ZuBAe2FUsKtyQJoQHlvP8OvBERxO3jEmy1I7hcRXcJBGGHFh/aJBswbXuS9sgrDH2QUO8ilkwNPHvHMd8clg== + dependencies: + has "^1.0.3" + +is-data-descriptor@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz" + integrity sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg== + dependencies: + kind-of "^3.0.2" + +is-data-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz" + integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ== + dependencies: + kind-of "^6.0.0" + +is-data-view@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/is-data-view/-/is-data-view-1.0.1.tgz#4b4d3a511b70f3dc26d42c03ca9ca515d847759f" + integrity sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w== + dependencies: + is-typed-array "^1.1.13" + +is-date-object@^1.0.1: + version "1.0.5" + resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz" + integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ== + dependencies: + has-tostringtag "^1.0.0" + +is-descriptor@^0.1.0: + version "0.1.6" + resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz" + integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg== + dependencies: + is-accessor-descriptor "^0.1.6" + is-data-descriptor "^0.1.4" + kind-of "^5.0.0" + +is-descriptor@^1.0.0, is-descriptor@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz" + integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg== + dependencies: + is-accessor-descriptor "^1.0.0" + is-data-descriptor "^1.0.0" + kind-of "^6.0.2" + +is-dotfile@^1.0.0: + version "1.0.3" + resolved "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz" + integrity sha512-9YclgOGtN/f8zx0Pr4FQYMdibBiTaH3sn52vjYip4ZSf6C4/6RfTEZ+MR4GvKhCxdPh21Bg42/WL55f6KSnKpg== + +is-equal-shallow@^0.1.3: + version "0.1.3" + resolved "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz" + integrity sha512-0EygVC5qPvIyb+gSz7zdD5/AAoS6Qrx1e//6N4yv4oNm30kqvdmG66oZFWVlQHUWe5OjP08FuTw2IdT0EOTcYA== + dependencies: + is-primitive "^2.0.0" + +is-extendable@^0.1.0, is-extendable@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz" + integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw== + +is-extendable@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz" + integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA== + dependencies: + is-plain-object "^2.0.4" + +is-extglob@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz" + integrity sha512-7Q+VbVafe6x2T+Tu6NcOf6sRklazEPmBoB3IWk3WdGZM2iGUwU/Oe3Wtq5lSEkDTTlpp8yx+5t4pzO/i9Ty1ww== + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-fullwidth-code-point@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz" + integrity sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-glob@^2.0.0, is-glob@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz" + integrity sha512-a1dBeB19NXsf/E0+FHqkagizel/LQw2DjSQpvQrj3zT+jYPpaUCryPnrQajXKFLCMuf4I6FhRpaGtw4lPrG6Eg== + dependencies: + is-extglob "^1.0.0" + +is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-hex-prefixed@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz" + integrity sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA== + +is-interactive@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz" + integrity sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w== + +is-negative-zero@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz" + integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA== + +is-negative-zero@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.3.tgz#ced903a027aca6381b777a5743069d7376a49747" + integrity sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw== + +is-number-object@^1.0.4: + version "1.0.7" + resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz" + integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ== + dependencies: + has-tostringtag "^1.0.0" + +is-number@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz" + integrity sha512-QUzH43Gfb9+5yckcrSA0VBDwEtDUchrk4F6tfJZQuNzDJbEDB9cZNzSfXGQ1jqmdDY/kl41lUOWM9syA8z8jlg== + dependencies: + kind-of "^3.0.2" + +is-number@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz" + integrity sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg== + dependencies: + kind-of "^3.0.2" + +is-number@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-4.0.0.tgz" + integrity sha512-rSklcAIlf1OmFdyAqbnWTLVelsQ58uvZ66S/ZyawjWqIviTWCjg2PzVGw8WUA+nNuPTqb4wgA+NszrJ+08LlgQ== + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-path-cwd@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-3.0.0.tgz" + integrity sha512-kyiNFFLU0Ampr6SDZitD/DwUo4Zs1nSdnygUBqsu3LooL00Qvb5j+UnvApUn/TTj1J3OuE6BTdQ5rudKmU2ZaA== + +is-path-inside@^3.0.3: + version "3.0.3" + resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz" + integrity sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ== + +is-path-inside@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/is-path-inside/-/is-path-inside-4.0.0.tgz" + integrity sha512-lJJV/5dYS+RcL8uQdBDW9c9uWFLLBNRyFhnAKXw5tVqLlKZ4RMGZKv+YQ/IA3OhD+RpbJa1LLFM1FQPGyIXvOA== + +is-plain-obj@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz" + integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg== + +is-plain-obj@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz" + integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA== + +is-plain-object@^2.0.3, is-plain-object@^2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz" + integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og== + dependencies: + isobject "^3.0.1" + +is-posix-bracket@^0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz" + integrity sha512-Yu68oeXJ7LeWNmZ3Zov/xg/oDBnBK2RNxwYY1ilNJX+tKKZqgPK+qOn/Gs9jEu66KDY9Netf5XLKNGzas/vPfQ== + +is-primitive@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz" + integrity sha512-N3w1tFaRfk3UrPfqeRyD+GYDASU3W5VinKhlORy8EWVf/sIdDL9GAcew85XmktCfH+ngG7SRXEVDoO18WMdB/Q== + +is-regex@^1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz" + integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-shared-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz" + integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA== + dependencies: + call-bind "^1.0.2" + +is-shared-array-buffer@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.3.tgz#1237f1cba059cdb62431d378dcc37d9680181688" + integrity sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg== + dependencies: + call-bind "^1.0.7" + +is-string@^1.0.5, is-string@^1.0.7: + version "1.0.7" + resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz" + integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg== + dependencies: + has-tostringtag "^1.0.0" + +is-subdir@^1.1.1: + version "1.2.0" + resolved "https://registry.npmjs.org/is-subdir/-/is-subdir-1.2.0.tgz" + integrity sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw== + dependencies: + better-path-resolve "1.0.0" + +is-symbol@^1.0.2, is-symbol@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz" + integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg== + dependencies: + has-symbols "^1.0.2" + +is-typed-array@^1.1.10, is-typed-array@^1.1.9: + version "1.1.10" + resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz" + integrity sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A== + dependencies: + available-typed-arrays "^1.0.5" + call-bind "^1.0.2" + for-each "^0.3.3" + gopd "^1.0.1" + has-tostringtag "^1.0.0" + +is-typed-array@^1.1.13: + version "1.1.13" + resolved "https://registry.yarnpkg.com/is-typed-array/-/is-typed-array-1.1.13.tgz#d6c5ca56df62334959322d7d7dd1cca50debe229" + integrity sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw== + dependencies: + which-typed-array "^1.1.14" + +is-typedarray@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz" + integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA== + +is-unicode-supported@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz" + integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw== + +is-url@^1.2.4: + version "1.2.4" + resolved "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz" + integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww== + +is-weakref@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz" + integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ== + dependencies: + call-bind "^1.0.2" + +is-windows@^1.0.0, is-windows@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz" + integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA== + +isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" + integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== + +isarray@^2.0.5: + version "2.0.5" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-2.0.5.tgz#8af1e4c1221244cc62459faf38940d4e644a5723" + integrity sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw== + +isexe@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz" + integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== + +isobject@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz" + integrity sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA== + dependencies: + isarray "1.0.0" + +isobject@^3.0.0, isobject@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz" + integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg== + +isomorphic-unfetch@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/isomorphic-unfetch/-/isomorphic-unfetch-3.1.0.tgz#87341d5f4f7b63843d468438128cb087b7c3e98f" + integrity sha512-geDJjpoZ8N0kWexiwkX8F9NkTsXhetLPVbZFQ+JTW239QNOwvB0gniuR1Wc6f0AMTn7/mFGyXvHTifrCp/GH8Q== + dependencies: + node-fetch "^2.6.1" + unfetch "^4.2.0" + +isstream@~0.1.2: + version "0.1.2" + resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz" + integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g== + +js-cookie@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/js-cookie/-/js-cookie-2.2.1.tgz#69e106dc5d5806894562902aa5baec3744e9b2b8" + integrity sha512-HvdH2LzI/EAZcUwA8+0nKNtWHqS+ZmijLA30RwZA0bo7ToCckjK5MkGhjED9KoRcXO6BaGI3I9UIzSA1FKFPOQ== + +js-sdsl@^4.1.4: + version "4.4.0" + resolved "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz" + integrity sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg== + +js-sha3@0.5.7: + version "0.5.7" + resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.5.7.tgz" + integrity sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g== + +js-sha3@0.8.0, js-sha3@^0.8.0: + version "0.8.0" + resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz" + integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q== + +js-tokens@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-yaml@3.13.1: + version "3.13.1" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz" + integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@3.x, js-yaml@^3.13.0, js-yaml@^3.13.1, js-yaml@^3.6.1: + version "3.14.1" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@4.1.0, js-yaml@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jsbn@~0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz" + integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg== + +json-bigint@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz" + integrity sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ== + dependencies: + bignumber.js "^9.0.0" + +json-buffer@3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz" + integrity sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ== + +json-parse-even-better-errors@^2.3.0: + version "2.3.1" + resolved "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz" + integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz" + integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== + +json-schema-traverse@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz" + integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== + +json-schema@0.4.0, json-schema@^0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz" + integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA== + +json-stable-stringify-without-jsonify@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz" + integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== + +json-stringify-safe@~5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz" + integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA== + +json5@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz" + integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA== + dependencies: + minimist "^1.2.0" + +jsonfile@^2.1.0: + version "2.4.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz" + integrity sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw== + optionalDependencies: + graceful-fs "^4.1.6" + +jsonfile@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz" + integrity sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg== + optionalDependencies: + graceful-fs "^4.1.6" + +jsonfile@^6.0.1: + version "6.1.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz" + integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ== + dependencies: + universalify "^2.0.0" + optionalDependencies: + graceful-fs "^4.1.6" + +jsonschema@^1.2.4: + version "1.4.1" + resolved "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz" + integrity sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ== + +jsprim@^1.2.2: + version "1.4.2" + resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz" + integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw== + dependencies: + assert-plus "1.0.0" + extsprintf "1.3.0" + json-schema "0.4.0" + verror "1.10.0" + +keccak@3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/keccak/-/keccak-3.0.1.tgz" + integrity sha512-epq90L9jlFWCW7+pQa6JOnKn2Xgl2mtI664seYR6MHskvI9agt7AnDqmAlp9TqU4/caMYbA08Hi5DMZAl5zdkA== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + +keccak@3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/keccak/-/keccak-3.0.2.tgz" + integrity sha512-PyKKjkH53wDMLGrvmRGSNWgmSxZOUqbnXwKL9tmgbFYA1iAYqW21kfR7mZXV0MlESiefxQQE9X9fTa3X+2MPDQ== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + readable-stream "^3.6.0" + +keccak@^1.0.2: + version "1.4.0" + resolved "https://registry.npmjs.org/keccak/-/keccak-1.4.0.tgz" + integrity sha512-eZVaCpblK5formjPjeTBik7TAg+pqnDrMHIffSvi9Lh7PQgM1+hSzakUeZFCk9DVVG0dacZJuaz2ntwlzZUIBw== + dependencies: + bindings "^1.2.1" + inherits "^2.0.3" + nan "^2.2.1" + safe-buffer "^5.1.0" + +keccak@^3.0.0, keccak@^3.0.2: + version "3.0.3" + resolved "https://registry.npmjs.org/keccak/-/keccak-3.0.3.tgz" + integrity sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + readable-stream "^3.6.0" + +keyv@^4.5.3: + version "4.5.4" + resolved "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz" + integrity sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw== + dependencies: + json-buffer "3.0.1" + +kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0: + version "3.2.2" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz" + integrity sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ== + dependencies: + is-buffer "^1.1.5" + +kind-of@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz" + integrity sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw== + dependencies: + is-buffer "^1.1.5" + +kind-of@^5.0.0: + version "5.1.0" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz" + integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw== + +kind-of@^6.0.0, kind-of@^6.0.2, kind-of@^6.0.3: + version "6.0.3" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz" + integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw== + +klaw@^1.0.0: + version "1.3.1" + resolved "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz" + integrity sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw== + optionalDependencies: + graceful-fs "^4.1.9" + +kleur@^4.1.5: + version "4.1.5" + resolved "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz" + integrity sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ== + +latest-version@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/latest-version/-/latest-version-7.0.0.tgz" + integrity sha512-KvNT4XqAMzdcL6ka6Tl3i2lYeFDgXNCuIX+xNx6ZMVR1dFq+idXd9FLKNMOIx0t9mJ9/HudyX4oZWXZQ0UJHeg== + dependencies: + package-json "^8.1.0" + +level-codec@^9.0.0: + version "9.0.2" + resolved "https://registry.npmjs.org/level-codec/-/level-codec-9.0.2.tgz" + integrity sha512-UyIwNb1lJBChJnGfjmO0OR+ezh2iVu1Kas3nvBS/BzGnx79dv6g7unpKIDNPMhfdTEGoc7mC8uAu51XEtX+FHQ== + dependencies: + buffer "^5.6.0" + +level-concat-iterator@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/level-concat-iterator/-/level-concat-iterator-3.1.0.tgz" + integrity sha512-BWRCMHBxbIqPxJ8vHOvKUsaO0v1sLYZtjN3K2iZJsRBYtp+ONsY6Jfi6hy9K3+zolgQRryhIn2NRZjZnWJ9NmQ== + dependencies: + catering "^2.1.0" + +level-concat-iterator@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/level-concat-iterator/-/level-concat-iterator-2.0.1.tgz" + integrity sha512-OTKKOqeav2QWcERMJR7IS9CUo1sHnke2C0gkSmcR7QuEtFNLLzHQAvnMw8ykvEcv0Qtkg0p7FOwP1v9e5Smdcw== + +level-errors@^2.0.0, level-errors@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/level-errors/-/level-errors-2.0.1.tgz" + integrity sha512-UVprBJXite4gPS+3VznfgDSU8PTRuVX0NXwoWW50KLxd2yw4Y1t2JUR5In1itQnudZqRMT9DlAM3Q//9NCjCFw== + dependencies: + errno "~0.1.1" + +level-iterator-stream@~4.0.0: + version "4.0.2" + resolved "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-4.0.2.tgz" + integrity sha512-ZSthfEqzGSOMWoUGhTXdX9jv26d32XJuHz/5YnuHZzH6wldfWMOVwI9TBtKcya4BKTyTt3XVA0A3cF3q5CY30Q== + dependencies: + inherits "^2.0.4" + readable-stream "^3.4.0" + xtend "^4.0.2" + +level-mem@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/level-mem/-/level-mem-5.0.1.tgz" + integrity sha512-qd+qUJHXsGSFoHTziptAKXoLX87QjR7v2KMbqncDXPxQuCdsQlzmyX+gwrEHhlzn08vkf8TyipYyMmiC6Gobzg== + dependencies: + level-packager "^5.0.3" + memdown "^5.0.0" + +level-packager@^5.0.3: + version "5.1.1" + resolved "https://registry.npmjs.org/level-packager/-/level-packager-5.1.1.tgz" + integrity sha512-HMwMaQPlTC1IlcwT3+swhqf/NUO+ZhXVz6TY1zZIIZlIR0YSn8GtAAWmIvKjNY16ZkEg/JcpAuQskxsXqC0yOQ== + dependencies: + encoding-down "^6.3.0" + levelup "^4.3.2" + +level-supports@^2.0.1: + version "2.1.0" + resolved "https://registry.npmjs.org/level-supports/-/level-supports-2.1.0.tgz" + integrity sha512-E486g1NCjW5cF78KGPrMDRBYzPuueMZ6VBXHT6gC7A8UYWGiM14fGgp+s/L1oFfDWSPV/+SFkYCmZ0SiESkRKA== + +level-supports@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/level-supports/-/level-supports-4.0.1.tgz" + integrity sha512-PbXpve8rKeNcZ9C1mUicC9auIYFyGpkV9/i6g76tLgANwWhtG2v7I4xNBUlkn3lE2/dZF3Pi0ygYGtLc4RXXdA== + +level-supports@~1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/level-supports/-/level-supports-1.0.1.tgz" + integrity sha512-rXM7GYnW8gsl1vedTJIbzOrRv85c/2uCMpiiCzO2fndd06U/kUXEEU9evYn4zFggBOg36IsBW8LzqIpETwwQzg== + dependencies: + xtend "^4.0.2" + +level-transcoder@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/level-transcoder/-/level-transcoder-1.0.1.tgz" + integrity sha512-t7bFwFtsQeD8cl8NIoQ2iwxA0CL/9IFw7/9gAjOonH0PWTTiRfY7Hq+Ejbsxh86tXobDQ6IOiddjNYIfOBs06w== + dependencies: + buffer "^6.0.3" + module-error "^1.0.1" + +level-ws@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/level-ws/-/level-ws-2.0.0.tgz" + integrity sha512-1iv7VXx0G9ec1isqQZ7y5LmoZo/ewAsyDHNA8EFDW5hqH2Kqovm33nSFkSdnLLAK+I5FlT+lo5Cw9itGe+CpQA== + dependencies: + inherits "^2.0.3" + readable-stream "^3.1.0" + xtend "^4.0.1" + +level@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/level/-/level-8.0.0.tgz" + integrity sha512-ypf0jjAk2BWI33yzEaaotpq7fkOPALKAgDBxggO6Q9HGX2MRXn0wbP1Jn/tJv1gtL867+YOjOB49WaUF3UoJNQ== + dependencies: + browser-level "^1.0.1" + classic-level "^1.2.0" + +leveldown@6.1.0: + version "6.1.0" + resolved "https://registry.npmjs.org/leveldown/-/leveldown-6.1.0.tgz" + integrity sha512-8C7oJDT44JXxh04aSSsfcMI8YiaGRhOFI9/pMEL7nWJLVsWajDPTRxsSHTM2WcTVY5nXM+SuRHzPPi0GbnDX+w== + dependencies: + abstract-leveldown "^7.2.0" + napi-macros "~2.0.0" + node-gyp-build "^4.3.0" + +levelup@^4.3.2: + version "4.4.0" + resolved "https://registry.npmjs.org/levelup/-/levelup-4.4.0.tgz" + integrity sha512-94++VFO3qN95cM/d6eBXvd894oJE0w3cInq9USsyQzzoJxmiYzPAocNcuGCPGGjoXqDVJcr3C1jzt1TSjyaiLQ== + dependencies: + deferred-leveldown "~5.3.0" + level-errors "~2.0.0" + level-iterator-stream "~4.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +levn@^0.4.1: + version "0.4.1" + resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz" + integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== + dependencies: + prelude-ls "^1.2.1" + type-check "~0.4.0" + +levn@~0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz" + integrity sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA== + dependencies: + prelude-ls "~1.1.2" + type-check "~0.3.2" + +lines-and-columns@^1.1.6: + version "1.2.4" + resolved "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz" + integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== + +load-yaml-file@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/load-yaml-file/-/load-yaml-file-0.2.0.tgz" + integrity sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw== + dependencies: + graceful-fs "^4.1.5" + js-yaml "^3.13.0" + pify "^4.0.1" + strip-bom "^3.0.0" + +locate-path@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz" + integrity sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA== + dependencies: + p-locate "^2.0.0" + path-exists "^3.0.0" + +locate-path@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz" + integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A== + dependencies: + p-locate "^3.0.0" + path-exists "^3.0.0" + +locate-path@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz" + integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== + dependencies: + p-locate "^4.1.0" + +locate-path@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz" + integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== + dependencies: + p-locate "^5.0.0" + +lodash.camelcase@^4.3.0: + version "4.3.0" + resolved "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz" + integrity sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA== + +lodash.clonedeep@^4.5.0: + version "4.5.0" + resolved "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz" + integrity sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ== + +lodash.merge@^4.6.2: + version "4.6.2" + resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz" + integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== + +lodash.startcase@^4.4.0: + version "4.4.0" + resolved "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz" + integrity sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg== + +lodash.truncate@^4.4.2: + version "4.4.2" + resolved "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz" + integrity sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw== + +lodash@^4.17.11, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.16, lodash@^4.17.19, lodash@^4.17.21: + version "4.17.21" + resolved "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +log-symbols@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz" + integrity sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ== + dependencies: + chalk "^2.4.2" + +log-symbols@4.1.0, log-symbols@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz" + integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg== + dependencies: + chalk "^4.1.0" + is-unicode-supported "^0.1.0" + +loupe@^2.3.1: + version "2.3.6" + resolved "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz" + integrity sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA== + dependencies: + get-func-name "^2.0.0" + +lowercase-keys@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-3.0.0.tgz" + integrity sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ== + +lru-cache@^4.0.1: + version "4.1.5" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz" + integrity sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g== + dependencies: + pseudomap "^1.0.2" + yallist "^2.1.2" + +lru-cache@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz" + integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== + dependencies: + yallist "^3.0.2" + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +lru_map@^0.3.3: + version "0.3.3" + resolved "https://registry.npmjs.org/lru_map/-/lru_map-0.3.3.tgz" + integrity sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ== + +ltgt@~2.2.0: + version "2.2.1" + resolved "https://registry.npmjs.org/ltgt/-/ltgt-2.2.1.tgz" + integrity sha512-AI2r85+4MquTw9ZYqabu4nMwy9Oftlfa/e/52t9IjtfG+mGBbTNdAoZ3RQKLHR6r0wQnwZnPIEh/Ya6XTWAKNA== + +make-error@^1.1.1: + version "1.3.6" + resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +map-cache@^0.2.2: + version "0.2.2" + resolved "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz" + integrity sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg== + +map-obj@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz" + integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg== + +map-obj@^4.0.0, map-obj@^4.1.0: + version "4.3.0" + resolved "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz" + integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ== + +map-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz" + integrity sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w== + dependencies: + object-visit "^1.0.0" + +markdown-table@^1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz" + integrity sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q== + +math-random@^1.0.1: + version "1.0.4" + resolved "https://registry.npmjs.org/math-random/-/math-random-1.0.4.tgz" + integrity sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A== + +mcl-wasm@^0.7.1: + version "0.7.9" + resolved "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.9.tgz" + integrity sha512-iJIUcQWA88IJB/5L15GnJVnSQJmf/YaxxV6zRavv83HILHaJQb6y0iFyDMdDO0gN8X37tdxmAOrH/P8B6RB8sQ== + +md5.js@^1.3.4: + version "1.3.5" + resolved "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz" + integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + safe-buffer "^5.1.2" + +memdown@^5.0.0: + version "5.1.0" + resolved "https://registry.npmjs.org/memdown/-/memdown-5.1.0.tgz" + integrity sha512-B3J+UizMRAlEArDjWHTMmadet+UKwHd3UjMgGBkZcKAxAYVPS9o0Yeiha4qvz7iGiL2Sb3igUft6p7nbFWctpw== + dependencies: + abstract-leveldown "~6.2.1" + functional-red-black-tree "~1.0.1" + immediate "~3.2.3" + inherits "~2.0.1" + ltgt "~2.2.0" + safe-buffer "~5.2.0" + +memory-level@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/memory-level/-/memory-level-1.0.0.tgz" + integrity sha512-UXzwewuWeHBz5krr7EvehKcmLFNoXxGcvuYhC41tRnkrTbJohtS7kVn9akmgirtRygg+f7Yjsfi8Uu5SGSQ4Og== + dependencies: + abstract-level "^1.0.0" + functional-red-black-tree "^1.0.1" + module-error "^1.0.1" + +memorystream@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz" + integrity sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw== + +meow@^10.1.3: + version "10.1.5" + resolved "https://registry.npmjs.org/meow/-/meow-10.1.5.tgz" + integrity sha512-/d+PQ4GKmGvM9Bee/DPa8z3mXs/pkvJE2KEThngVNOqtmljC6K7NMPxtc2JeZYTmpWb9k/TmxjeL18ez3h7vCw== + dependencies: + "@types/minimist" "^1.2.2" + camelcase-keys "^7.0.0" + decamelize "^5.0.0" + decamelize-keys "^1.1.0" + hard-rejection "^2.1.0" + minimist-options "4.1.0" + normalize-package-data "^3.0.2" + read-pkg-up "^8.0.0" + redent "^4.0.0" + trim-newlines "^4.0.2" + type-fest "^1.2.2" + yargs-parser "^20.2.9" + +meow@^6.0.0: + version "6.1.1" + resolved "https://registry.npmjs.org/meow/-/meow-6.1.1.tgz" + integrity sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg== + dependencies: + "@types/minimist" "^1.2.0" + camelcase-keys "^6.2.2" + decamelize-keys "^1.1.0" + hard-rejection "^2.1.0" + minimist-options "^4.0.2" + normalize-package-data "^2.5.0" + read-pkg-up "^7.0.1" + redent "^3.0.0" + trim-newlines "^3.0.0" + type-fest "^0.13.1" + yargs-parser "^18.1.3" + +merge2@^1.2.3, merge2@^1.3.0, merge2@^1.4.1: + version "1.4.1" + resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +merkle-patricia-tree@^4.2.2, merkle-patricia-tree@^4.2.4: + version "4.2.4" + resolved "https://registry.npmjs.org/merkle-patricia-tree/-/merkle-patricia-tree-4.2.4.tgz" + integrity sha512-eHbf/BG6eGNsqqfbLED9rIqbsF4+sykEaBn6OLNs71tjclbMcMOk1tEPmJKcNcNCLkvbpY/lwyOlizWsqPNo8w== + dependencies: + "@types/levelup" "^4.3.0" + ethereumjs-util "^7.1.4" + level-mem "^5.0.1" + level-ws "^2.0.0" + readable-stream "^3.6.0" + semaphore-async-await "^1.5.1" + +micro-ftch@^0.3.1: + version "0.3.1" + resolved "https://registry.yarnpkg.com/micro-ftch/-/micro-ftch-0.3.1.tgz#6cb83388de4c1f279a034fb0cf96dfc050853c5f" + integrity sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg== + +micromatch@^2.1.5: + version "2.3.11" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz" + integrity sha512-LnU2XFEk9xxSJ6rfgAry/ty5qwUTyHYOBU0g4R6tIw5ljwgGIBmiKhRWLw5NpMOnrgUNcDJ4WMp8rl3sYVHLNA== + dependencies: + arr-diff "^2.0.0" + array-unique "^0.2.1" + braces "^1.8.2" + expand-brackets "^0.1.4" + extglob "^0.3.1" + filename-regex "^2.0.0" + is-extglob "^1.0.0" + is-glob "^2.0.1" + kind-of "^3.0.2" + normalize-path "^2.0.1" + object.omit "^2.0.0" + parse-glob "^3.0.4" + regex-cache "^0.4.2" + +micromatch@^3.1.10: + version "3.1.10" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz" + integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + braces "^2.3.1" + define-property "^2.0.2" + extend-shallow "^3.0.2" + extglob "^2.0.4" + fragment-cache "^0.2.1" + kind-of "^6.0.2" + nanomatch "^1.2.9" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.2" + +micromatch@^4.0.2, micromatch@^4.0.4: + version "4.0.5" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz" + integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA== + dependencies: + braces "^3.0.2" + picomatch "^2.3.1" + +miller-rabin@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz" + integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA== + dependencies: + bn.js "^4.0.0" + brorand "^1.0.1" + +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== + +mime-types@^2.1.12, mime-types@~2.1.19: + version "2.1.35" + resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== + dependencies: + mime-db "1.52.0" + +mimic-fn@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz" + integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== + +mimic-response@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz" + integrity sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ== + +mimic-response@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz" + integrity sha512-e5ISH9xMYU0DzrT+jl8q2ze9D6eWBto+I8CNpe+VI+K2J/F/k3PdkdTdz4wvGVH4NTpo+NRYTVIuMQEMMcsLqg== + +min-indent@^1.0.0, min-indent@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz" + integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg== + +minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz" + integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A== + +minimalistic-crypto-utils@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz" + integrity sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg== + +"minimatch@2 || 3", minimatch@^3.0.2, minimatch@^3.0.4, minimatch@^3.0.5, minimatch@^3.1.1, minimatch@^3.1.2: + version "3.1.2" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +minimatch@3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz" + integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== + dependencies: + brace-expansion "^1.1.7" + +minimatch@5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz" + integrity sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g== + dependencies: + brace-expansion "^2.0.1" + +minimatch@^5.0.1: + version "5.1.6" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz" + integrity sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g== + dependencies: + brace-expansion "^2.0.1" + +minimist-options@4.1.0, minimist-options@^4.0.2: + version "4.1.0" + resolved "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz" + integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A== + dependencies: + arrify "^1.0.1" + is-plain-obj "^1.1.0" + kind-of "^6.0.3" + +minimist@^1.1.0, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@^1.2.7: + version "1.2.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== + +mixin-deep@^1.2.0: + version "1.3.2" + resolved "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz" + integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA== + dependencies: + for-in "^1.0.2" + is-extendable "^1.0.1" + +mixme@^0.5.1: + version "0.5.9" + resolved "https://registry.npmjs.org/mixme/-/mixme-0.5.9.tgz" + integrity sha512-VC5fg6ySUscaWUpI4gxCBTQMH2RdUpNrk+MsbpCYtIvf9SBJdiUey4qE7BXviJsJR4nDQxCZ+3yaYNW3guz/Pw== + +mkdirp@0.5.5: + version "0.5.5" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz" + integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== + dependencies: + minimist "^1.2.5" + +mkdirp@0.5.x, mkdirp@^0.5.1: + version "0.5.6" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz" + integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== + dependencies: + minimist "^1.2.6" + +mkdirp@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +mnemonist@^0.38.0: + version "0.38.5" + resolved "https://registry.npmjs.org/mnemonist/-/mnemonist-0.38.5.tgz" + integrity sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg== + dependencies: + obliterator "^2.0.0" + +mocha@^10.0.0, mocha@^10.2.0: + version "10.2.0" + resolved "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz" + integrity sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg== + dependencies: + ansi-colors "4.1.1" + browser-stdout "1.3.1" + chokidar "3.5.3" + debug "4.3.4" + diff "5.0.0" + escape-string-regexp "4.0.0" + find-up "5.0.0" + glob "7.2.0" + he "1.2.0" + js-yaml "4.1.0" + log-symbols "4.1.0" + minimatch "5.0.1" + ms "2.1.3" + nanoid "3.3.3" + serialize-javascript "6.0.0" + strip-json-comments "3.1.1" + supports-color "8.1.1" + workerpool "6.2.1" + yargs "16.2.0" + yargs-parser "20.2.4" + yargs-unparser "2.0.0" + +mocha@^7.1.1: + version "7.2.0" + resolved "https://registry.npmjs.org/mocha/-/mocha-7.2.0.tgz" + integrity sha512-O9CIypScywTVpNaRrCAgoUnJgozpIofjKUYmJhiCIJMiuYnLI6otcb1/kpW9/n/tJODHGZ7i8aLQoDVsMtOKQQ== + dependencies: + ansi-colors "3.2.3" + browser-stdout "1.3.1" + chokidar "3.3.0" + debug "3.2.6" + diff "3.5.0" + escape-string-regexp "1.0.5" + find-up "3.0.0" + glob "7.1.3" + growl "1.10.5" + he "1.2.0" + js-yaml "3.13.1" + log-symbols "3.0.0" + minimatch "3.0.4" + mkdirp "0.5.5" + ms "2.1.1" + node-environment-flags "1.0.6" + object.assign "4.1.0" + strip-json-comments "2.0.1" + supports-color "6.0.0" + which "1.3.1" + wide-align "1.1.3" + yargs "13.3.2" + yargs-parser "13.1.2" + yargs-unparser "1.6.0" + +module-error@^1.0.1, module-error@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/module-error/-/module-error-1.0.2.tgz" + integrity sha512-0yuvsqSCv8LbaOKhnsQ/T5JhyFlCYLPXK3U2sgV10zoKQwzs/MyfuQUOZQ1V/6OCOJsK/TRgNVrPuPDqtdMFtA== + +ms@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz" + integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== + +ms@2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz" + integrity sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg== + +ms@2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz" + integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== + +ms@2.1.3, ms@^2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mute-stream@0.0.8: + version "0.0.8" + resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz" + integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA== + +nan@^2.12.1, nan@^2.14.0, nan@^2.2.1: + version "2.17.0" + resolved "https://registry.npmjs.org/nan/-/nan-2.17.0.tgz" + integrity sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ== + +nanoid@3.3.3: + version "3.3.3" + resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz" + integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w== + +nanomatch@^1.2.9: + version "1.2.13" + resolved "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz" + integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + define-property "^2.0.2" + extend-shallow "^3.0.2" + fragment-cache "^0.2.1" + is-windows "^1.0.2" + kind-of "^6.0.2" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +napi-macros@^2.2.2: + version "2.2.2" + resolved "https://registry.npmjs.org/napi-macros/-/napi-macros-2.2.2.tgz" + integrity sha512-hmEVtAGYzVQpCKdbQea4skABsdXW4RUh5t5mJ2zzqowJS2OyXZTU1KhDVFhx+NlWZ4ap9mqR9TcDO3LTTttd+g== + +napi-macros@~2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/napi-macros/-/napi-macros-2.0.0.tgz" + integrity sha512-A0xLykHtARfueITVDernsAWdtIMbOJgKgcluwENp3AlsKN/PloyO10HtmoqnFAQAcxPkgZN7wdfPfEd0zNGxbg== + +natural-compare-lite@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz" + integrity sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g== + +natural-compare@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz" + integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== + +neo-async@^2.6.0: + version "2.6.2" + resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz" + integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw== + +node-addon-api@^2.0.0: + version "2.0.2" + resolved "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz" + integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA== + +node-emoji@^1.10.0: + version "1.11.0" + resolved "https://registry.npmjs.org/node-emoji/-/node-emoji-1.11.0.tgz" + integrity sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A== + dependencies: + lodash "^4.17.21" + +node-environment-flags@1.0.6: + version "1.0.6" + resolved "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz" + integrity sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw== + dependencies: + object.getownpropertydescriptors "^2.0.3" + semver "^5.7.0" + +node-fetch@^2.6.0, node-fetch@^2.6.1: + version "2.7.0" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.7.0.tgz#d0f0fa6e3e2dc1d27efcd8ad99d550bda94d187d" + integrity sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A== + dependencies: + whatwg-url "^5.0.0" + +node-fetch@^2.6.7: + version "2.6.9" + resolved "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.9.tgz" + integrity sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg== + dependencies: + whatwg-url "^5.0.0" + +node-gyp-build@4.3.0: + version "4.3.0" + resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.3.0.tgz" + integrity sha512-iWjXZvmboq0ja1pUGULQBexmxq8CV4xBhX7VDOTbL7ZR4FOowwY/VOtRxBN/yKxmdGoIp4j5ysNT4u3S2pDQ3Q== + +node-gyp-build@4.4.0: + version "4.4.0" + resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.4.0.tgz" + integrity sha512-amJnQCcgtRVw9SvoebO3BKGESClrfXGCUTX9hSn1OuGQTQBOZmVd0Z0OlecpuRksKvbsUqALE8jls/ErClAPuQ== + +node-gyp-build@^4.2.0, node-gyp-build@^4.3.0: + version "4.6.0" + resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz" + integrity sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ== + +nofilter@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/nofilter/-/nofilter-3.1.0.tgz" + integrity sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g== + +nopt@3.x: + version "3.0.6" + resolved "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz" + integrity sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg== + dependencies: + abbrev "1" + +normalize-package-data@^2.5.0: + version "2.5.0" + resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz" + integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA== + dependencies: + hosted-git-info "^2.1.4" + resolve "^1.10.0" + semver "2 || 3 || 4 || 5" + validate-npm-package-license "^3.0.1" + +normalize-package-data@^3.0.2: + version "3.0.3" + resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz" + integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA== + dependencies: + hosted-git-info "^4.0.1" + is-core-module "^2.5.0" + semver "^7.3.4" + validate-npm-package-license "^3.0.1" + +normalize-path@^2.0.0, normalize-path@^2.0.1: + version "2.1.1" + resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz" + integrity sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w== + dependencies: + remove-trailing-separator "^1.0.1" + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +normalize-url@^8.0.0: + version "8.0.1" + resolved "https://registry.npmjs.org/normalize-url/-/normalize-url-8.0.1.tgz" + integrity sha512-IO9QvjUMWxPQQhs60oOu10CRkWCiZzSUkzbXGGV9pviYl1fXYcvkzQ5jV9z8Y6un8ARoVRl4EtC6v6jNqbaJ/w== + +number-to-bn@1.7.0: + version "1.7.0" + resolved "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz" + integrity sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig== + dependencies: + bn.js "4.11.6" + strip-hex-prefix "1.0.0" + +oauth-sign@~0.9.0: + version "0.9.0" + resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz" + integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== + +object-assign@^4.1.0: + version "4.1.1" + resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz" + integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== + +object-copy@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz" + integrity sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ== + dependencies: + copy-descriptor "^0.1.0" + define-property "^0.2.5" + kind-of "^3.0.3" + +object-inspect@^1.12.3, object-inspect@^1.9.0: + version "1.12.3" + resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz" + integrity sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g== + +object-inspect@^1.13.1: + version "1.13.2" + resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.13.2.tgz#dea0088467fb991e67af4058147a24824a3043ff" + integrity sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g== + +object-keys@^1.0.11, object-keys@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz" + integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== + +object-visit@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz" + integrity sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA== + dependencies: + isobject "^3.0.0" + +object.assign@4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz" + integrity sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w== + dependencies: + define-properties "^1.1.2" + function-bind "^1.1.1" + has-symbols "^1.0.0" + object-keys "^1.0.11" + +object.assign@^4.1.4: + version "4.1.4" + resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz" + integrity sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + has-symbols "^1.0.3" + object-keys "^1.1.1" + +object.assign@^4.1.5: + version "4.1.5" + resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.5.tgz#3a833f9ab7fdb80fc9e8d2300c803d216d8fdbb0" + integrity sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ== + dependencies: + call-bind "^1.0.5" + define-properties "^1.2.1" + has-symbols "^1.0.3" + object-keys "^1.1.1" + +object.getownpropertydescriptors@^2.0.3: + version "2.1.5" + resolved "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.5.tgz" + integrity sha512-yDNzckpM6ntyQiGTik1fKV1DcVDRS+w8bvpWNCBanvH5LfRX9O8WTHqQzG4RZwRAM4I0oU7TV11Lj5v0g20ibw== + dependencies: + array.prototype.reduce "^1.0.5" + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + +object.omit@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz" + integrity sha512-UiAM5mhmIuKLsOvrL+B0U2d1hXHF3bFYWIuH1LMpuV2EJEHG1Ntz06PgLEHjm6VFd87NpH8rastvPoyv6UW2fA== + dependencies: + for-own "^0.1.4" + is-extendable "^0.1.1" + +object.pick@^1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz" + integrity sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ== + dependencies: + isobject "^3.0.1" + +object.values@^1.1.6: + version "1.1.6" + resolved "https://registry.npmjs.org/object.values/-/object.values-1.1.6.tgz" + integrity sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + +obliterator@^2.0.0: + version "2.0.4" + resolved "https://registry.npmjs.org/obliterator/-/obliterator-2.0.4.tgz" + integrity sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ== + +once@1.x, once@^1.3.0: + version "1.4.0" + resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +onetime@^5.1.0: + version "5.1.2" + resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz" + integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== + dependencies: + mimic-fn "^2.1.0" + +optionator@^0.8.1: + version "0.8.3" + resolved "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz" + integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== + dependencies: + deep-is "~0.1.3" + fast-levenshtein "~2.0.6" + levn "~0.3.0" + prelude-ls "~1.1.2" + type-check "~0.3.2" + word-wrap "~1.2.3" + +optionator@^0.9.1: + version "0.9.1" + resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz" + integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw== + dependencies: + deep-is "^0.1.3" + fast-levenshtein "^2.0.6" + levn "^0.4.1" + prelude-ls "^1.2.1" + type-check "^0.4.0" + word-wrap "^1.2.3" + +ora@^5.4.1: + version "5.4.1" + resolved "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz" + integrity sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ== + dependencies: + bl "^4.1.0" + chalk "^4.1.0" + cli-cursor "^3.1.0" + cli-spinners "^2.5.0" + is-interactive "^1.0.0" + is-unicode-supported "^0.1.0" + log-symbols "^4.1.0" + strip-ansi "^6.0.0" + wcwidth "^1.0.1" + +ordinal@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/ordinal/-/ordinal-1.0.3.tgz" + integrity sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ== + +os-tmpdir@~1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz" + integrity sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g== + +outdent@^0.5.0: + version "0.5.0" + resolved "https://registry.npmjs.org/outdent/-/outdent-0.5.0.tgz" + integrity sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q== + +p-cancelable@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/p-cancelable/-/p-cancelable-3.0.0.tgz" + integrity sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw== + +p-filter@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/p-filter/-/p-filter-2.1.0.tgz" + integrity sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw== + dependencies: + p-map "^2.0.0" + +p-limit@^1.1.0: + version "1.3.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz" + integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q== + dependencies: + p-try "^1.0.0" + +p-limit@^2.0.0, p-limit@^2.2.0: + version "2.3.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz" + integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== + dependencies: + p-try "^2.0.0" + +p-limit@^3.0.2: + version "3.1.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz" + integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== + dependencies: + yocto-queue "^0.1.0" + +p-locate@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz" + integrity sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg== + dependencies: + p-limit "^1.1.0" + +p-locate@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz" + integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ== + dependencies: + p-limit "^2.0.0" + +p-locate@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz" + integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== + dependencies: + p-limit "^2.2.0" + +p-locate@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz" + integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== + dependencies: + p-limit "^3.0.2" + +p-map@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/p-map/-/p-map-2.1.0.tgz" + integrity sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw== + +p-map@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz" + integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ== + dependencies: + aggregate-error "^3.0.0" + +p-map@^5.5.0: + version "5.5.0" + resolved "https://registry.npmjs.org/p-map/-/p-map-5.5.0.tgz" + integrity sha512-VFqfGDHlx87K66yZrNdI4YGtD70IRyd+zSvgks6mzHPRNkoKy+9EKP4SFC77/vTTQYmRmti7dvqC+m5jBrBAcg== + dependencies: + aggregate-error "^4.0.0" + +p-try@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz" + integrity sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww== + +p-try@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz" + integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== + +package-json@^8.1.0: + version "8.1.1" + resolved "https://registry.npmjs.org/package-json/-/package-json-8.1.1.tgz" + integrity sha512-cbH9IAIJHNj9uXi196JVsRlt7cHKak6u/e6AkL/bkRelZ7rlL3X1YKxsZwa36xipOEKAsdtmaG6aAJoM1fx2zA== + dependencies: + got "^12.1.0" + registry-auth-token "^5.0.1" + registry-url "^6.0.0" + semver "^7.3.7" + +parent-module@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz" + integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== + dependencies: + callsites "^3.0.0" + +parse-cache-control@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/parse-cache-control/-/parse-cache-control-1.0.1.tgz" + integrity sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg== + +parse-glob@^3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz" + integrity sha512-FC5TeK0AwXzq3tUBFtH74naWkPQCEWs4K+xMxWZBlKDWu0bVHXGZa+KKqxKidd7xwhdZ19ZNuF2uO1M/r196HA== + dependencies: + glob-base "^0.3.0" + is-dotfile "^1.0.0" + is-extglob "^1.0.0" + is-glob "^2.0.0" + +parse-json@^5.0.0, parse-json@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz" + integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== + dependencies: + "@babel/code-frame" "^7.0.0" + error-ex "^1.3.1" + json-parse-even-better-errors "^2.3.0" + lines-and-columns "^1.1.6" + +pascalcase@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz" + integrity sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw== + +path-browserify@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz" + integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g== + +path-exists@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz" + integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ== + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz" + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== + +path-key@^3.1.0: + version "3.1.1" + resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-parse@^1.0.6, path-parse@^1.0.7: + version "1.0.7" + resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +path-starts-with@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/path-starts-with/-/path-starts-with-2.0.0.tgz" + integrity sha512-3UHTHbJz5+NLkPafFR+2ycJOjoc4WV2e9qCZCnm71zHiWaFrm1XniLVTkZXvaRgxr1xFh9JsTdicpH2yM03nLA== + +path-type@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz" + integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== + +pathval@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz" + integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ== + +pbkdf2@^3.0.17, pbkdf2@^3.0.9: + version "3.1.2" + resolved "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz" + integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA== + dependencies: + create-hash "^1.1.2" + create-hmac "^1.1.4" + ripemd160 "^2.0.1" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +performance-now@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz" + integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow== + +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1: + version "2.3.1" + resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pify@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz" + integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g== + +pkg-dir@^4.2.0: + version "4.2.0" + resolved "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz" + integrity sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ== + dependencies: + find-up "^4.0.0" + +pluralize@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz" + integrity sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA== + +posix-character-classes@^0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz" + integrity sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg== + +possible-typed-array-names@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/possible-typed-array-names/-/possible-typed-array-names-1.0.0.tgz#89bb63c6fada2c3e90adc4a647beeeb39cc7bf8f" + integrity sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q== + +preferred-pm@^3.0.0: + version "3.0.3" + resolved "https://registry.npmjs.org/preferred-pm/-/preferred-pm-3.0.3.tgz" + integrity sha512-+wZgbxNES/KlJs9q40F/1sfOd/j7f1O9JaHcW5Dsn3aUUOZg3L2bjpVUcKV2jvtElYfoTuQiNeMfQJ4kwUAhCQ== + dependencies: + find-up "^5.0.0" + find-yarn-workspace-root2 "1.2.16" + path-exists "^4.0.0" + which-pm "2.0.0" + +prelude-ls@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz" + integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== + +prelude-ls@~1.1.2: + version "1.1.2" + resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz" + integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w== + +preserve@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz" + integrity sha512-s/46sYeylUfHNjI+sA/78FAHlmIuKqI9wNnzEOGehAlUUYeObv5C2mOinXBjyUyWmJ2SfcS2/ydApH4hTF4WXQ== + +prettier-linter-helpers@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz" + integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== + dependencies: + fast-diff "^1.1.2" + +prettier@^2.3.1, prettier@^2.7.1, prettier@^2.8.3: + version "2.8.7" + resolved "https://registry.npmjs.org/prettier/-/prettier-2.8.7.tgz" + integrity sha512-yPngTo3aXUUmyuTjeTUT75txrf+aMh9FiD7q9ZE/i6r0bPb22g4FsE6Y338PQX1bmfy08i9QQCB7/rcUAVntfw== + +process-nextick-args@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz" + integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== + +promise@^8.0.0: + version "8.3.0" + resolved "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz" + integrity sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg== + dependencies: + asap "~2.0.6" + +proper-lockfile@^4.1.1: + version "4.1.2" + resolved "https://registry.yarnpkg.com/proper-lockfile/-/proper-lockfile-4.1.2.tgz#c8b9de2af6b2f1601067f98e01ac66baa223141f" + integrity sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== + dependencies: + graceful-fs "^4.2.4" + retry "^0.12.0" + signal-exit "^3.0.2" + +proto-list@~1.2.1: + version "1.2.4" + resolved "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz" + integrity sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA== + +proxy-from-env@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz" + integrity sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg== + +prr@~1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz" + integrity sha512-yPw4Sng1gWghHQWj0B3ZggWUm4qVbPwPFcRG8KyxiU7J2OHFSoEHKS+EZ3fv5l1t9CyCiop6l/ZYeWbrgoQejw== + +pseudomap@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz" + integrity sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ== + +psl@^1.1.28: + version "1.9.0" + resolved "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz" + integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag== + +punycode@1.3.2: + version "1.3.2" + resolved "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz" + integrity sha512-RofWgt/7fL5wP1Y7fxE7/EmTLzQVnB0ycyibJ0OOHIlJqTNzglYFxVwETOcIoJqJmpDXJ9xImDv+Fq34F/d4Dw== + +punycode@^2.1.0, punycode@^2.1.1: + version "2.3.0" + resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz" + integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA== + +qs@^6.4.0, qs@^6.7.0: + version "6.11.1" + resolved "https://registry.npmjs.org/qs/-/qs-6.11.1.tgz" + integrity sha512-0wsrzgTz/kAVIeuxSjnpGC56rzYtr6JT/2BwEvMaPhFIoYa1aGO8LbzuU1R0uUYQkLpWBTOj0l/CLAJB64J6nQ== + dependencies: + side-channel "^1.0.4" + +qs@~6.5.2: + version "6.5.3" + resolved "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz" + integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA== + +querystring@0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz" + integrity sha512-X/xY82scca2tau62i9mDyU9K+I+djTMUsvwf7xnUX5GLvVzgJybOJf4Y6o9Zx3oJK/LSXg5tTZBjwzqVPaPO2g== + +queue-microtask@^1.2.2, queue-microtask@^1.2.3: + version "1.2.3" + resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +quick-lru@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-4.0.1.tgz" + integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g== + +quick-lru@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz" + integrity sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA== + +randomatic@^3.0.0: + version "3.1.1" + resolved "https://registry.npmjs.org/randomatic/-/randomatic-3.1.1.tgz" + integrity sha512-TuDE5KxZ0J461RVjrJZCJc+J+zCkTb1MbH9AQUq68sMhOMcy9jLcb3BrZKgp9q9Ncltdg4QVqWrH02W2EFFVYw== + dependencies: + is-number "^4.0.0" + kind-of "^6.0.0" + math-random "^1.0.1" + +randombytes@^2.0.1, randombytes@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz" + integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ== + dependencies: + safe-buffer "^5.1.0" + +raw-body@^2.4.1: + version "2.5.2" + resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz" + integrity sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA== + dependencies: + bytes "3.1.2" + http-errors "2.0.0" + iconv-lite "0.4.24" + unpipe "1.0.0" + +rc@1.2.8: + version "1.2.8" + resolved "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz" + integrity sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw== + dependencies: + deep-extend "^0.6.0" + ini "~1.3.0" + minimist "^1.2.0" + strip-json-comments "~2.0.1" + +read-pkg-up@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-7.0.1.tgz" + integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg== + dependencies: + find-up "^4.1.0" + read-pkg "^5.2.0" + type-fest "^0.8.1" + +read-pkg-up@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-8.0.0.tgz" + integrity sha512-snVCqPczksT0HS2EC+SxUndvSzn6LRCwpfSvLrIfR5BKDQQZMaI6jPRC9dYvYFDRAuFEAnkwww8kBBNE/3VvzQ== + dependencies: + find-up "^5.0.0" + read-pkg "^6.0.0" + type-fest "^1.0.1" + +read-pkg@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-5.2.0.tgz" + integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg== + dependencies: + "@types/normalize-package-data" "^2.4.0" + normalize-package-data "^2.5.0" + parse-json "^5.0.0" + type-fest "^0.6.0" + +read-pkg@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-6.0.0.tgz" + integrity sha512-X1Fu3dPuk/8ZLsMhEj5f4wFAF0DWoK7qhGJvgaijocXxBmSToKfbFtqbxMO7bVjNA1dmE5huAzjXj/ey86iw9Q== + dependencies: + "@types/normalize-package-data" "^2.4.0" + normalize-package-data "^3.0.2" + parse-json "^5.2.0" + type-fest "^1.0.1" + +read-yaml-file@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/read-yaml-file/-/read-yaml-file-1.1.0.tgz" + integrity sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA== + dependencies: + graceful-fs "^4.1.5" + js-yaml "^3.6.1" + pify "^4.0.1" + strip-bom "^3.0.0" + +readable-stream@^2.0.2, readable-stream@^2.2.2: + version "2.3.8" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz" + integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA== + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.3" + isarray "~1.0.0" + process-nextick-args "~2.0.0" + safe-buffer "~5.1.1" + string_decoder "~1.1.1" + util-deprecate "~1.0.1" + +readable-stream@^3.1.0, readable-stream@^3.4.0, readable-stream@^3.6.0: + version "3.6.2" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz" + integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA== + dependencies: + inherits "^2.0.3" + string_decoder "^1.1.1" + util-deprecate "^1.0.1" + +readdirp@^2.0.0: + version "2.2.1" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz" + integrity sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ== + dependencies: + graceful-fs "^4.1.11" + micromatch "^3.1.10" + readable-stream "^2.0.2" + +readdirp@~3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz" + integrity sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ== + dependencies: + picomatch "^2.0.4" + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +rechoir@^0.6.2: + version "0.6.2" + resolved "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz" + integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw== + dependencies: + resolve "^1.1.6" + +recursive-readdir@^2.2.2: + version "2.2.3" + resolved "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz" + integrity sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA== + dependencies: + minimatch "^3.0.5" + +redent@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz" + integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg== + dependencies: + indent-string "^4.0.0" + strip-indent "^3.0.0" + +redent@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/redent/-/redent-4.0.0.tgz" + integrity sha512-tYkDkVVtYkSVhuQ4zBgfvciymHaeuel+zFKXShfDnFP5SyVEP7qo70Rf1jTOTCx3vGNAbnEi/xFkcfQVMIBWag== + dependencies: + indent-string "^5.0.0" + strip-indent "^4.0.0" + +reduce-flatten@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-2.0.0.tgz" + integrity sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w== + +regenerator-runtime@^0.11.0: + version "0.11.1" + resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz" + integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg== + +regenerator-runtime@^0.13.11: + version "0.13.11" + resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz" + integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg== + +regex-cache@^0.4.2: + version "0.4.4" + resolved "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz" + integrity sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ== + dependencies: + is-equal-shallow "^0.1.3" + +regex-not@^1.0.0, regex-not@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz" + integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A== + dependencies: + extend-shallow "^3.0.2" + safe-regex "^1.1.0" + +regexp.prototype.flags@^1.4.3: + version "1.4.3" + resolved "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz" + integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + functions-have-names "^1.2.2" + +regexp.prototype.flags@^1.5.2: + version "1.5.2" + resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.5.2.tgz#138f644a3350f981a858c44f6bb1a61ff59be334" + integrity sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw== + dependencies: + call-bind "^1.0.6" + define-properties "^1.2.1" + es-errors "^1.3.0" + set-function-name "^2.0.1" + +regexpp@^3.0.0: + version "3.2.0" + resolved "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz" + integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== + +registry-auth-token@^5.0.1: + version "5.0.2" + resolved "https://registry.npmjs.org/registry-auth-token/-/registry-auth-token-5.0.2.tgz" + integrity sha512-o/3ikDxtXaA59BmZuZrJZDJv8NMDGSj+6j6XaeBmHw8eY1i1qd9+6H+LjVvQXx3HN6aRCGa1cUdJ9RaJZUugnQ== + dependencies: + "@pnpm/npm-conf" "^2.1.0" + +registry-url@^6.0.0: + version "6.0.1" + resolved "https://registry.npmjs.org/registry-url/-/registry-url-6.0.1.tgz" + integrity sha512-+crtS5QjFRqFCoQmvGduwYWEBng99ZvmFvF+cUJkGYF1L1BfU8C6Zp9T7f5vPAwyLkUExpvK+ANVZmGU49qi4Q== + dependencies: + rc "1.2.8" + +remove-trailing-separator@^1.0.1: + version "1.1.0" + resolved "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz" + integrity sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw== + +repeat-element@^1.1.2: + version "1.1.4" + resolved "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.4.tgz" + integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ== + +repeat-string@^1.5.2, repeat-string@^1.6.1: + version "1.6.1" + resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz" + integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w== + +req-cwd@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/req-cwd/-/req-cwd-2.0.0.tgz" + integrity sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ== + dependencies: + req-from "^2.0.0" + +req-from@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/req-from/-/req-from-2.0.0.tgz" + integrity sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA== + dependencies: + resolve-from "^3.0.0" + +request-promise-core@1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz" + integrity sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw== + dependencies: + lodash "^4.17.19" + +request-promise-native@^1.0.5: + version "1.0.9" + resolved "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz" + integrity sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g== + dependencies: + request-promise-core "1.1.4" + stealthy-require "^1.1.1" + tough-cookie "^2.3.3" + +request@^2.85.0, request@^2.88.0: + version "2.88.2" + resolved "https://registry.npmjs.org/request/-/request-2.88.2.tgz" + integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw== + dependencies: + aws-sign2 "~0.7.0" + aws4 "^1.8.0" + caseless "~0.12.0" + combined-stream "~1.0.6" + extend "~3.0.2" + forever-agent "~0.6.1" + form-data "~2.3.2" + har-validator "~5.1.3" + http-signature "~1.2.0" + is-typedarray "~1.0.0" + isstream "~0.1.2" + json-stringify-safe "~5.0.1" + mime-types "~2.1.19" + oauth-sign "~0.9.0" + performance-now "^2.1.0" + qs "~6.5.2" + safe-buffer "^5.1.2" + tough-cookie "~2.5.0" + tunnel-agent "^0.6.0" + uuid "^3.3.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +require-from-string@^2.0.0, require-from-string@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz" + integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== + +require-main-filename@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz" + integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg== + +requireindex@~1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/requireindex/-/requireindex-1.2.0.tgz" + integrity sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww== + +resolve-alpn@^1.2.0: + version "1.2.1" + resolved "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz" + integrity sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g== + +resolve-from@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz" + integrity sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw== + +resolve-from@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz" + integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== + +resolve-from@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz" + integrity sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw== + +resolve-url@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz" + integrity sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg== + +resolve@1.1.x: + version "1.1.7" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz" + integrity sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg== + +resolve@1.17.0: + version "1.17.0" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz" + integrity sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w== + dependencies: + path-parse "^1.0.6" + +resolve@^1.1.6, resolve@^1.10.0, resolve@^1.10.1, resolve@^1.22.0, resolve@^1.22.1: + version "1.22.3" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.3.tgz" + integrity sha512-P8ur/gp/AmbEzjr729bZnLjXK5Z+4P0zhIJgBgzqRih7hL7BOukHGtSTA3ACMY467GRFz3duQsi0bDZdR7DKdw== + dependencies: + is-core-module "^2.12.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +resolve@^1.1.7: + version "1.22.2" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.2.tgz" + integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g== + dependencies: + is-core-module "^2.11.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +responselike@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/responselike/-/responselike-3.0.0.tgz" + integrity sha512-40yHxbNcl2+rzXvZuVkrYohathsSJlMTXKryG5y8uciHv1+xDLHQpgjG64JUO9nrEq2jGLH6IZ8BcZyw3wrweg== + dependencies: + lowercase-keys "^3.0.0" + +restore-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz" + integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA== + dependencies: + onetime "^5.1.0" + signal-exit "^3.0.2" + +ret@~0.1.10: + version "0.1.15" + resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz" + integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== + +retry@0.13.1: + version "0.13.1" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.13.1.tgz#185b1587acf67919d63b357349e03537b2484658" + integrity sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg== + +retry@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b" + integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow== + +reusify@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz" + integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== + +rimraf@^2.2.8, rimraf@^2.6.2: + version "2.7.1" + resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz" + integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w== + dependencies: + glob "^7.1.3" + +rimraf@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + +ripemd160@^2.0.0, ripemd160@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz" + integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + +rlp@2.2.6: + version "2.2.6" + resolved "https://registry.npmjs.org/rlp/-/rlp-2.2.6.tgz" + integrity sha512-HAfAmL6SDYNWPUOJNrM500x4Thn4PZsEy5pijPh40U9WfNk0z15hUYzO9xVIMAdIHdFtD8CBDHd75Td1g36Mjg== + dependencies: + bn.js "^4.11.1" + +rlp@^2.0.0, rlp@^2.2.3, rlp@^2.2.4: + version "2.2.7" + resolved "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz" + integrity sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ== + dependencies: + bn.js "^5.2.0" + +run-async@^2.4.0: + version "2.4.1" + resolved "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz" + integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ== + +run-parallel-limit@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/run-parallel-limit/-/run-parallel-limit-1.1.0.tgz" + integrity sha512-jJA7irRNM91jaKc3Hcl1npHsFLOXOoTkPCUL1JEa1R82O2miplXXRaGdjW/KM/98YQWDhJLiSs793CnXfblJUw== + dependencies: + queue-microtask "^1.2.2" + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +rustbn.js@~0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz" + integrity sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA== + +rxjs@^7.2.0, rxjs@^7.5.5: + version "7.8.0" + resolved "https://registry.npmjs.org/rxjs/-/rxjs-7.8.0.tgz" + integrity sha512-F2+gxDshqmIub1KdvZkaEfGDwLNpPvk9Fs6LD/MyQxNgMds/WH9OdDDXOmxUZpME+iSK3rQCctkL0DYyytUqMg== + dependencies: + tslib "^2.1.0" + +safe-array-concat@^1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/safe-array-concat/-/safe-array-concat-1.1.2.tgz#81d77ee0c4e8b863635227c721278dd524c20edb" + integrity sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q== + dependencies: + call-bind "^1.0.7" + get-intrinsic "^1.2.4" + has-symbols "^1.0.3" + isarray "^2.0.5" + +safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0: + version "5.2.1" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +safe-buffer@~5.1.0, safe-buffer@~5.1.1: + version "5.1.2" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz" + integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== + +safe-regex-test@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz" + integrity sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.1.3" + is-regex "^1.1.4" + +safe-regex-test@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/safe-regex-test/-/safe-regex-test-1.0.3.tgz#a5b4c0f06e0ab50ea2c395c14d8371232924c377" + integrity sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw== + dependencies: + call-bind "^1.0.6" + es-errors "^1.3.0" + is-regex "^1.1.4" + +safe-regex@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz" + integrity sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg== + dependencies: + ret "~0.1.10" + +"safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0: + version "2.1.2" + resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +sc-istanbul@^0.4.5: + version "0.4.6" + resolved "https://registry.npmjs.org/sc-istanbul/-/sc-istanbul-0.4.6.tgz" + integrity sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g== + dependencies: + abbrev "1.0.x" + async "1.x" + escodegen "1.8.x" + esprima "2.7.x" + glob "^5.0.15" + handlebars "^4.0.1" + js-yaml "3.x" + mkdirp "0.5.x" + nopt "3.x" + once "1.x" + resolve "1.1.x" + supports-color "^3.1.0" + which "^1.1.1" + wordwrap "^1.0.0" + +scrypt-js@2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-2.0.4.tgz" + integrity sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw== + +scrypt-js@3.0.1, scrypt-js@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz" + integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA== + +secp256k1@4.0.3, secp256k1@^4.0.1: + version "4.0.3" + resolved "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz" + integrity sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA== + dependencies: + elliptic "^6.5.4" + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + +secp256k1@^3.0.1: + version "3.8.0" + resolved "https://registry.npmjs.org/secp256k1/-/secp256k1-3.8.0.tgz" + integrity sha512-k5ke5avRZbtl9Tqx/SA7CbY3NF6Ro+Sj9cZxezFzuBlLDmyqPiL8hJJ+EmzD8Ig4LUDByHJ3/iPOVoRixs/hmw== + dependencies: + bindings "^1.5.0" + bip66 "^1.1.5" + bn.js "^4.11.8" + create-hash "^1.2.0" + drbg.js "^1.0.1" + elliptic "^6.5.2" + nan "^2.14.0" + safe-buffer "^5.1.2" + +seedrandom@3.0.5: + version "3.0.5" + resolved "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz" + integrity sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg== + +semaphore-async-await@^1.5.1: + version "1.5.1" + resolved "https://registry.npmjs.org/semaphore-async-await/-/semaphore-async-await-1.5.1.tgz" + integrity sha512-b/ptP11hETwYWpeilHXXQiV5UJNJl7ZWWooKRE5eBIYWoom6dZ0SluCIdCtKycsMtZgKWE01/qAw6jblw1YVhg== + +"semver@2 || 3 || 4 || 5", semver@^5.4.1, semver@^5.5.0, semver@^5.7.0: + version "5.7.1" + resolved "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz" + integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== + +semver@^6.1.0, semver@^6.3.0: + version "6.3.0" + resolved "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz" + integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== + +semver@^7.3.4, semver@^7.3.7: + version "7.4.0" + resolved "https://registry.npmjs.org/semver/-/semver-7.4.0.tgz" + integrity sha512-RgOxM8Mw+7Zus0+zcLEUn8+JfoLpj/huFTItQy2hsM4khuC1HYRDp0cU482Ewn/Fcy6bCjufD8vAj7voC66KQw== + dependencies: + lru-cache "^6.0.0" + +semver@^7.5.2: + version "7.6.2" + resolved "https://registry.npmjs.org/semver/-/semver-7.6.2.tgz" + integrity sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w== + +serialize-javascript@6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz" + integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag== + dependencies: + randombytes "^2.1.0" + +set-blocking@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz" + integrity sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw== + +set-function-length@^1.2.1: + version "1.2.2" + resolved "https://registry.yarnpkg.com/set-function-length/-/set-function-length-1.2.2.tgz#aac72314198eaed975cf77b2c3b6b880695e5449" + integrity sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg== + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + function-bind "^1.1.2" + get-intrinsic "^1.2.4" + gopd "^1.0.1" + has-property-descriptors "^1.0.2" + +set-function-name@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/set-function-name/-/set-function-name-2.0.2.tgz#16a705c5a0dc2f5e638ca96d8a8cd4e1c2b90985" + integrity sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ== + dependencies: + define-data-property "^1.1.4" + es-errors "^1.3.0" + functions-have-names "^1.2.3" + has-property-descriptors "^1.0.2" + +set-value@^2.0.0, set-value@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz" + integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw== + dependencies: + extend-shallow "^2.0.1" + is-extendable "^0.1.1" + is-plain-object "^2.0.3" + split-string "^3.0.1" + +setimmediate@1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.4.tgz" + integrity sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog== + +setimmediate@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz" + integrity sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA== + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +sha.js@^2.4.0, sha.js@^2.4.8: + version "2.4.11" + resolved "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz" + integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +sha1@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/sha1/-/sha1-1.1.1.tgz" + integrity sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA== + dependencies: + charenc ">= 0.0.1" + crypt ">= 0.0.1" + +shebang-command@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz" + integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg== + dependencies: + shebang-regex "^1.0.0" + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz" + integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ== + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +shell-quote@^1.6.1: + version "1.8.1" + resolved "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.1.tgz" + integrity sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA== + +shelljs@^0.8.3: + version "0.8.5" + resolved "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz" + integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow== + dependencies: + glob "^7.0.0" + interpret "^1.0.0" + rechoir "^0.6.2" + +side-channel@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz" + integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw== + dependencies: + call-bind "^1.0.0" + get-intrinsic "^1.0.2" + object-inspect "^1.9.0" + +signal-exit@^3.0.2: + version "3.0.7" + resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz" + integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== + +slash@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz" + integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== + +slash@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz" + integrity sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew== + +slice-ansi@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz" + integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ== + dependencies: + ansi-styles "^4.0.0" + astral-regex "^2.0.0" + is-fullwidth-code-point "^3.0.0" + +smartwrap@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/smartwrap/-/smartwrap-2.0.2.tgz" + integrity sha512-vCsKNQxb7PnCNd2wY1WClWifAc2lwqsG8OaswpJkVJsvMGcnEntdTCDajZCkk93Ay1U3t/9puJmb525Rg5MZBA== + dependencies: + array.prototype.flat "^1.2.3" + breakword "^1.0.5" + grapheme-splitter "^1.0.4" + strip-ansi "^6.0.0" + wcwidth "^1.0.1" + yargs "^15.1.0" + +snapdragon-node@^2.0.1: + version "2.1.1" + resolved "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz" + integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw== + dependencies: + define-property "^1.0.0" + isobject "^3.0.0" + snapdragon-util "^3.0.1" + +snapdragon-util@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz" + integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ== + dependencies: + kind-of "^3.2.0" + +snapdragon@^0.8.1: + version "0.8.2" + resolved "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz" + integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg== + dependencies: + base "^0.11.1" + debug "^2.2.0" + define-property "^0.2.5" + extend-shallow "^2.0.1" + map-cache "^0.2.2" + source-map "^0.5.6" + source-map-resolve "^0.5.0" + use "^3.1.0" + +solc@0.7.3: + version "0.7.3" + resolved "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz" + integrity sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA== + dependencies: + command-exists "^1.2.8" + commander "3.0.2" + follow-redirects "^1.12.1" + fs-extra "^0.30.0" + js-sha3 "0.8.0" + memorystream "^0.3.1" + require-from-string "^2.0.0" + semver "^5.5.0" + tmp "0.0.33" + +solc@0.8.15: + version "0.8.15" + resolved "https://registry.npmjs.org/solc/-/solc-0.8.15.tgz" + integrity sha512-Riv0GNHNk/SddN/JyEuFKwbcWcEeho15iyupTSHw5Np6WuXA5D8kEHbyzDHi6sqmvLzu2l+8b1YmL8Ytple+8w== + dependencies: + command-exists "^1.2.8" + commander "^8.1.0" + follow-redirects "^1.12.1" + js-sha3 "0.8.0" + memorystream "^0.3.1" + semver "^5.5.0" + tmp "0.0.33" + +solhint@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/solhint/-/solhint-5.0.1.tgz" + integrity sha512-QeQLS9HGCnIiibt+xiOa/+MuP7BWz9N7C5+Mj9pLHshdkNhuo3AzCpWmjfWVZBUuwIUO3YyCRVIcYLR3YOKGfg== + dependencies: + "@solidity-parser/parser" "^0.18.0" + ajv "^6.12.6" + antlr4 "^4.13.1-patch-1" + ast-parents "^0.0.1" + chalk "^4.1.2" + commander "^10.0.0" + cosmiconfig "^8.0.0" + fast-diff "^1.2.0" + glob "^8.0.3" + ignore "^5.2.4" + js-yaml "^4.1.0" + latest-version "^7.0.0" + lodash "^4.17.21" + pluralize "^8.0.0" + semver "^7.5.2" + strip-ansi "^6.0.1" + table "^6.8.1" + text-table "^0.2.0" + optionalDependencies: + prettier "^2.8.3" + +solidity-ast@^0.4.51: + version "0.4.56" + resolved "https://registry.yarnpkg.com/solidity-ast/-/solidity-ast-0.4.56.tgz#94fe296f12e8de1a3bed319bc06db8d05a113d7a" + integrity sha512-HgmsA/Gfklm/M8GFbCX/J1qkVH0spXHgALCNZ8fA8x5X+MFdn/8CP2gr5OVyXjXw6RZTPC/Sxl2RUDQOXyNMeA== + dependencies: + array.prototype.findlast "^1.2.2" + +solidity-coverage@^0.8.12: + version "0.8.12" + resolved "https://registry.yarnpkg.com/solidity-coverage/-/solidity-coverage-0.8.12.tgz#c4fa2f64eff8ada7a1387b235d6b5b0e6c6985ed" + integrity sha512-8cOB1PtjnjFRqOgwFiD8DaUsYJtVJ6+YdXQtSZDrLGf8cdhhh8xzTtGzVTGeBf15kTv0v7lYPJlV/az7zLEPJw== + dependencies: + "@ethersproject/abi" "^5.0.9" + "@solidity-parser/parser" "^0.18.0" + chalk "^2.4.2" + death "^1.1.0" + difflib "^0.2.4" + fs-extra "^8.1.0" + ghost-testrpc "^0.0.2" + global-modules "^2.0.0" + globby "^10.0.1" + jsonschema "^1.2.4" + lodash "^4.17.21" + mocha "^10.2.0" + node-emoji "^1.10.0" + pify "^4.0.1" + recursive-readdir "^2.2.2" + sc-istanbul "^0.4.5" + semver "^7.3.4" + shelljs "^0.8.3" + web3-utils "^1.3.6" + +source-map-resolve@^0.5.0: + version "0.5.3" + resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz" + integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw== + dependencies: + atob "^2.1.2" + decode-uri-component "^0.2.0" + resolve-url "^0.2.1" + source-map-url "^0.4.0" + urix "^0.1.0" + +source-map-support@^0.5.13, source-map-support@^0.5.6: + version "0.5.21" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz" + integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map-url@^0.4.0: + version "0.4.1" + resolved "https://registry.npmjs.org/source-map-url/-/source-map-url-0.4.1.tgz" + integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw== + +source-map@^0.5.6: + version "0.5.7" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz" + integrity sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ== + +source-map@^0.6.0, source-map@^0.6.1: + version "0.6.1" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +source-map@~0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz" + integrity sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA== + dependencies: + amdefine ">=0.0.4" + +spawndamnit@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/spawndamnit/-/spawndamnit-2.0.0.tgz" + integrity sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA== + dependencies: + cross-spawn "^5.1.0" + signal-exit "^3.0.2" + +spdx-correct@^3.0.0: + version "3.2.0" + resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.2.0.tgz" + integrity sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA== + dependencies: + spdx-expression-parse "^3.0.0" + spdx-license-ids "^3.0.0" + +spdx-exceptions@^2.1.0: + version "2.3.0" + resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz" + integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A== + +spdx-expression-parse@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz" + integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q== + dependencies: + spdx-exceptions "^2.1.0" + spdx-license-ids "^3.0.0" + +spdx-license-ids@^3.0.0: + version "3.0.13" + resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.13.tgz" + integrity sha512-XkD+zwiqXHikFZm4AX/7JSCXA98U5Db4AFd5XUg/+9UNtnH75+Z9KxtpYiJZx36mUDVOwH83pl7yvCer6ewM3w== + +split-string@^3.0.1, split-string@^3.0.2: + version "3.1.0" + resolved "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz" + integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw== + dependencies: + extend-shallow "^3.0.0" + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz" + integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== + +sshpk@^1.7.0: + version "1.17.0" + resolved "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz" + integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ== + dependencies: + asn1 "~0.2.3" + assert-plus "^1.0.0" + bcrypt-pbkdf "^1.0.0" + dashdash "^1.12.0" + ecc-jsbn "~0.1.1" + getpass "^0.1.1" + jsbn "~0.1.0" + safer-buffer "^2.0.2" + tweetnacl "~0.14.0" + +stacktrace-parser@^0.1.10: + version "0.1.10" + resolved "https://registry.npmjs.org/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz" + integrity sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg== + dependencies: + type-fest "^0.7.1" + +static-extend@^0.1.1: + version "0.1.2" + resolved "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz" + integrity sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g== + dependencies: + define-property "^0.2.5" + object-copy "^0.1.0" + +statuses@2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== + +stealthy-require@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz" + integrity sha512-ZnWpYnYugiOVEY5GkcuJK1io5V8QmNYChG62gSit9pQVGErXtrKuPC55ITaVSukmMta5qpMU7vqLt2Lnni4f/g== + +stream-transform@^2.1.3: + version "2.1.3" + resolved "https://registry.npmjs.org/stream-transform/-/stream-transform-2.1.3.tgz" + integrity sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ== + dependencies: + mixme "^0.5.1" + +streamsearch@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz" + integrity sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg== + +string-format@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/string-format/-/string-format-2.0.0.tgz" + integrity sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA== + +"string-width@^1.0.2 || 2", string-width@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz" + integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw== + dependencies: + is-fullwidth-code-point "^2.0.0" + strip-ansi "^4.0.0" + +string-width@^3.0.0, string-width@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz" + integrity sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w== + dependencies: + emoji-regex "^7.0.1" + is-fullwidth-code-point "^2.0.0" + strip-ansi "^5.1.0" + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string.prototype.trim@^1.2.7: + version "1.2.7" + resolved "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz" + integrity sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + +string.prototype.trim@^1.2.9: + version "1.2.9" + resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz#b6fa326d72d2c78b6df02f7759c73f8f6274faa4" + integrity sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-abstract "^1.23.0" + es-object-atoms "^1.0.0" + +string.prototype.trimend@^1.0.6: + version "1.0.6" + resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz" + integrity sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + +string.prototype.trimend@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz#3651b8513719e8a9f48de7f2f77640b26652b229" + integrity sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + +string.prototype.trimstart@^1.0.6: + version "1.0.6" + resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz" + integrity sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + +string.prototype.trimstart@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz#7ee834dda8c7c17eff3118472bb35bfedaa34dde" + integrity sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg== + dependencies: + call-bind "^1.0.7" + define-properties "^1.2.1" + es-object-atoms "^1.0.0" + +string_decoder@^1.1.1: + version "1.3.0" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz" + integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== + dependencies: + safe-buffer "~5.2.0" + +string_decoder@~1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz" + integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== + dependencies: + safe-buffer "~5.1.0" + +strip-ansi@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz" + integrity sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow== + dependencies: + ansi-regex "^3.0.0" + +strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz" + integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA== + dependencies: + ansi-regex "^4.1.0" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-bom@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz" + integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== + +strip-hex-prefix@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz" + integrity sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A== + dependencies: + is-hex-prefixed "1.0.0" + +strip-indent@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz" + integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ== + dependencies: + min-indent "^1.0.0" + +strip-indent@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/strip-indent/-/strip-indent-4.0.0.tgz" + integrity sha512-mnVSV2l+Zv6BLpSD/8V87CW/y9EmmbYzGCIavsnsI6/nwn26DwffM/yztm30Z/I2DY9wdS3vXVCMnHDgZaVNoA== + dependencies: + min-indent "^1.0.1" + +strip-json-comments@2.0.1, strip-json-comments@~2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz" + integrity sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ== + +strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz" + integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== + +subarg@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz" + integrity sha512-RIrIdRY0X1xojthNcVtgT9sjpOGagEUKpZdgBUi054OEPFo282yg+zE+t1Rj3+RqKq2xStL7uUHhY+AjbC4BXg== + dependencies: + minimist "^1.1.0" + +supports-color@6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz" + integrity sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg== + dependencies: + has-flag "^3.0.0" + +supports-color@8.1.1: + version "8.1.1" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz" + integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== + dependencies: + has-flag "^4.0.0" + +supports-color@^3.1.0: + version "3.2.3" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz" + integrity sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A== + dependencies: + has-flag "^1.0.0" + +supports-color@^5.3.0: + version "5.5.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz" + integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== + dependencies: + has-flag "^3.0.0" + +supports-color@^7.1.0: + version "7.2.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + +sync-request@^6.0.0: + version "6.1.0" + resolved "https://registry.npmjs.org/sync-request/-/sync-request-6.1.0.tgz" + integrity sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw== + dependencies: + http-response-object "^3.0.1" + sync-rpc "^1.2.1" + then-request "^6.0.0" + +sync-rpc@^1.2.1: + version "1.3.6" + resolved "https://registry.npmjs.org/sync-rpc/-/sync-rpc-1.3.6.tgz" + integrity sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw== + dependencies: + get-port "^3.1.0" + +table-layout@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/table-layout/-/table-layout-1.0.2.tgz" + integrity sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A== + dependencies: + array-back "^4.0.1" + deep-extend "~0.6.0" + typical "^5.2.0" + wordwrapjs "^4.0.0" + +table@^6.8.0, table@^6.8.1: + version "6.8.1" + resolved "https://registry.npmjs.org/table/-/table-6.8.1.tgz" + integrity sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA== + dependencies: + ajv "^8.0.1" + lodash.truncate "^4.4.2" + slice-ansi "^4.0.0" + string-width "^4.2.3" + strip-ansi "^6.0.1" + +term-size@^2.1.0: + version "2.2.1" + resolved "https://registry.npmjs.org/term-size/-/term-size-2.2.1.tgz" + integrity sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg== + +text-table@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz" + integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw== + +then-request@^6.0.0: + version "6.0.2" + resolved "https://registry.npmjs.org/then-request/-/then-request-6.0.2.tgz" + integrity sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA== + dependencies: + "@types/concat-stream" "^1.6.0" + "@types/form-data" "0.0.33" + "@types/node" "^8.0.0" + "@types/qs" "^6.2.31" + caseless "~0.12.0" + concat-stream "^1.6.0" + form-data "^2.2.0" + http-basic "^8.1.1" + http-response-object "^3.0.1" + promise "^8.0.0" + qs "^6.4.0" + +through@^2.3.6: + version "2.3.8" + resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz" + integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg== + +tmp@0.0.33, tmp@^0.0.33: + version "0.0.33" + resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz" + integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw== + dependencies: + os-tmpdir "~1.0.2" + +to-object-path@^0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz" + integrity sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg== + dependencies: + kind-of "^3.0.2" + +to-regex-range@^2.1.0: + version "2.1.1" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz" + integrity sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg== + dependencies: + is-number "^3.0.0" + repeat-string "^1.6.1" + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +to-regex@^3.0.1, to-regex@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz" + integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw== + dependencies: + define-property "^2.0.2" + extend-shallow "^3.0.2" + regex-not "^1.0.2" + safe-regex "^1.1.0" + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +tough-cookie@^2.3.3, tough-cookie@~2.5.0: + version "2.5.0" + resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz" + integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g== + dependencies: + psl "^1.1.28" + punycode "^2.1.1" + +tr46@~0.0.3: + version "0.0.3" + resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz" + integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== + +trim-newlines@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-3.0.1.tgz" + integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw== + +trim-newlines@^4.0.2: + version "4.1.1" + resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-4.1.1.tgz" + integrity sha512-jRKj0n0jXWo6kh62nA5TEh3+4igKDXLvzBJcPpiizP7oOolUrYIxmVBG9TOtHYFHoddUk6YvAkGeGoSVTXfQXQ== + +ts-command-line-args@^2.2.0: + version "2.5.0" + resolved "https://registry.npmjs.org/ts-command-line-args/-/ts-command-line-args-2.5.0.tgz" + integrity sha512-Ff7Xt04WWCjj/cmPO9eWTJX3qpBZWuPWyQYG1vnxJao+alWWYjwJBc5aYz3h5p5dE08A6AnpkgiCtP/0KXXBYw== + dependencies: + "@morgan-stanley/ts-mocking-bird" "^0.6.2" + chalk "^4.1.0" + command-line-args "^5.1.1" + command-line-usage "^6.1.0" + string-format "^2.0.0" + +ts-essentials@^7.0.1: + version "7.0.3" + resolved "https://registry.npmjs.org/ts-essentials/-/ts-essentials-7.0.3.tgz" + integrity sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ== + +ts-mocha@^10.0.0: + version "10.0.0" + resolved "https://registry.npmjs.org/ts-mocha/-/ts-mocha-10.0.0.tgz" + integrity sha512-VRfgDO+iiuJFlNB18tzOfypJ21xn2xbuZyDvJvqpTbWgkAgD17ONGr8t+Tl8rcBtOBdjXp5e/Rk+d39f7XBHRw== + dependencies: + ts-node "7.0.1" + optionalDependencies: + tsconfig-paths "^3.5.0" + +ts-node@10.8.1: + version "10.8.1" + resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.8.1.tgz" + integrity sha512-Wwsnao4DQoJsN034wePSg5nZiw4YKXf56mPIAeD6wVmiv+RytNSWqc2f3fKvcUoV+Yn2+yocD71VOfQHbmVX4g== + dependencies: + "@cspotcode/source-map-support" "^0.8.0" + "@tsconfig/node10" "^1.0.7" + "@tsconfig/node12" "^1.0.7" + "@tsconfig/node14" "^1.0.0" + "@tsconfig/node16" "^1.0.2" + acorn "^8.4.1" + acorn-walk "^8.1.1" + arg "^4.1.0" + create-require "^1.1.0" + diff "^4.0.1" + make-error "^1.1.1" + v8-compile-cache-lib "^3.0.1" + yn "3.1.1" + +ts-node@7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/ts-node/-/ts-node-7.0.1.tgz" + integrity sha512-BVwVbPJRspzNh2yfslyT1PSbl5uIk03EZlb493RKHN4qej/D06n1cEhjlOJG69oFsE7OT8XjpTUcYf6pKTLMhw== + dependencies: + arrify "^1.0.0" + buffer-from "^1.1.0" + diff "^3.1.0" + make-error "^1.1.1" + minimist "^1.2.0" + mkdirp "^0.5.1" + source-map-support "^0.5.6" + yn "^2.0.0" + +tsconfig-paths@^3.14.1, tsconfig-paths@^3.5.0: + version "3.14.2" + resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.2.tgz" + integrity sha512-o/9iXgCYc5L/JxCHPe3Hvh8Q/2xm5Z+p18PESBU6Ff33695QnCHBEjcytY2q19ua7Mbl/DavtBOLq+oG0RCL+g== + dependencies: + "@types/json5" "^0.0.29" + json5 "^1.0.2" + minimist "^1.2.6" + strip-bom "^3.0.0" + +tslib@^1.11.1, tslib@^1.8.1, tslib@^1.9.3: + version "1.14.1" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" + integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== + +tslib@^2.1.0: + version "2.5.0" + resolved "https://registry.npmjs.org/tslib/-/tslib-2.5.0.tgz" + integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg== + +tslib@^2.3.1, tslib@^2.6.2: + version "2.6.3" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.3.tgz#0438f810ad7a9edcde7a241c3d80db693c8cbfe0" + integrity sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ== + +tsort@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/tsort/-/tsort-0.0.1.tgz" + integrity sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw== + +tsutils@^3.21.0: + version "3.21.0" + resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz" + integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA== + dependencies: + tslib "^1.8.1" + +tty-table@^4.1.5: + version "4.2.1" + resolved "https://registry.npmjs.org/tty-table/-/tty-table-4.2.1.tgz" + integrity sha512-xz0uKo+KakCQ+Dxj1D/tKn2FSyreSYWzdkL/BYhgN6oMW808g8QRMuh1atAV9fjTPbWBjfbkKQpI/5rEcnAc7g== + dependencies: + chalk "^4.1.2" + csv "^5.5.3" + kleur "^4.1.5" + smartwrap "^2.0.2" + strip-ansi "^6.0.1" + wcwidth "^1.0.1" + yargs "^17.7.1" + +tunnel-agent@^0.6.0: + version "0.6.0" + resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz" + integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== + dependencies: + safe-buffer "^5.0.1" + +tweetnacl-util@^0.15.1: + version "0.15.1" + resolved "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz" + integrity sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw== + +tweetnacl@^0.14.3, tweetnacl@~0.14.0: + version "0.14.5" + resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz" + integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA== + +tweetnacl@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz" + integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw== + +type-check@^0.4.0, type-check@~0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz" + integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== + dependencies: + prelude-ls "^1.2.1" + +type-check@~0.3.2: + version "0.3.2" + resolved "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz" + integrity sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg== + dependencies: + prelude-ls "~1.1.2" + +type-detect@^4.0.0, type-detect@^4.0.5: + version "4.0.8" + resolved "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz" + integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== + +type-fest@^0.13.1: + version "0.13.1" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz" + integrity sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg== + +type-fest@^0.20.2: + version "0.20.2" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz" + integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== + +type-fest@^0.21.3: + version "0.21.3" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz" + integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== + +type-fest@^0.6.0: + version "0.6.0" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.6.0.tgz" + integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg== + +type-fest@^0.7.1: + version "0.7.1" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.7.1.tgz" + integrity sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg== + +type-fest@^0.8.1: + version "0.8.1" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz" + integrity sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA== + +type-fest@^1.0.1, type-fest@^1.2.1, type-fest@^1.2.2: + version "1.4.0" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz" + integrity sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA== + +typechain@^8.0.0, typechain@^8.1.0: + version "8.1.1" + resolved "https://registry.npmjs.org/typechain/-/typechain-8.1.1.tgz" + integrity sha512-uF/sUvnXTOVF2FHKhQYnxHk4su4JjZR8vr4mA2mBaRwHTbwh0jIlqARz9XJr1tA0l7afJGvEa1dTSi4zt039LQ== + dependencies: + "@types/prettier" "^2.1.1" + debug "^4.3.1" + fs-extra "^7.0.0" + glob "7.1.7" + js-sha3 "^0.8.0" + lodash "^4.17.15" + mkdirp "^1.0.4" + prettier "^2.3.1" + ts-command-line-args "^2.2.0" + ts-essentials "^7.0.1" + +typed-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/typed-array-buffer/-/typed-array-buffer-1.0.2.tgz#1867c5d83b20fcb5ccf32649e5e2fc7424474ff3" + integrity sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ== + dependencies: + call-bind "^1.0.7" + es-errors "^1.3.0" + is-typed-array "^1.1.13" + +typed-array-byte-length@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz#d92972d3cff99a3fa2e765a28fcdc0f1d89dec67" + integrity sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw== + dependencies: + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + +typed-array-byte-offset@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/typed-array-byte-offset/-/typed-array-byte-offset-1.0.2.tgz#f9ec1acb9259f395093e4567eb3c28a580d02063" + integrity sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + +typed-array-length@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz" + integrity sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng== + dependencies: + call-bind "^1.0.2" + for-each "^0.3.3" + is-typed-array "^1.1.9" + +typed-array-length@^1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/typed-array-length/-/typed-array-length-1.0.6.tgz#57155207c76e64a3457482dfdc1c9d1d3c4c73a3" + integrity sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g== + dependencies: + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-proto "^1.0.3" + is-typed-array "^1.1.13" + possible-typed-array-names "^1.0.0" + +typedarray@^0.0.6: + version "0.0.6" + resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz" + integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA== + +typescript@^4.6.3: + version "4.9.5" + resolved "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz" + integrity sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g== + +typical@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz" + integrity sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw== + +typical@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz" + integrity sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg== + +uglify-js@^3.1.4: + version "3.17.4" + resolved "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz" + integrity sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g== + +unbox-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz" + integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw== + dependencies: + call-bind "^1.0.2" + has-bigints "^1.0.2" + has-symbols "^1.0.3" + which-boxed-primitive "^1.0.2" + +undici@^5.14.0: + version "5.21.2" + resolved "https://registry.npmjs.org/undici/-/undici-5.21.2.tgz" + integrity sha512-f6pTQ9RF4DQtwoWSaC42P/NKlUjvezVvd9r155ohqkwFNRyBKM3f3pcty3ouusefNRyM25XhIQEbeQ46sZDJfQ== + dependencies: + busboy "^1.6.0" + +unfetch@^4.2.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/unfetch/-/unfetch-4.2.0.tgz#7e21b0ef7d363d8d9af0fb929a5555f6ef97a3be" + integrity sha512-F9p7yYCn6cIW9El1zi0HI6vqpeIvBsr3dSuRO6Xuppb1u5rXpCPmMvLSyECLhybr9isec8Ohl0hPekMVrEinDA== + +union-value@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz" + integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg== + dependencies: + arr-union "^3.1.0" + get-value "^2.0.6" + is-extendable "^0.1.1" + set-value "^2.0.1" + +uniswap-v2-deploy-plugin@^0.0.4: + version "0.0.4" + resolved "https://registry.yarnpkg.com/uniswap-v2-deploy-plugin/-/uniswap-v2-deploy-plugin-0.0.4.tgz#9eeb1e48ecd3f02b195210fd1eebbe624ee87ad9" + integrity sha512-4+1tfxul77SedONq1hwQixF2vwH/zy9KLj9XcA3QYPN5SUcp5ZgGYZFxPAmZJOEDAAWBz2oHJT26oLjbyuZrVg== + dependencies: + "@openzeppelin/contracts" "^4.3.2" + "@uniswap/v2-core" "^1.0.1" + "@uniswap/v2-periphery" "1.1.0-beta.0" + +universalify@^0.1.0: + version "0.1.2" + resolved "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz" + integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg== + +universalify@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz" + integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ== + +unpipe@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz" + integrity sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ== + +unset-value@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz" + integrity sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ== + dependencies: + has-value "^0.3.1" + isobject "^3.0.0" + +uri-js@^4.2.2: + version "4.4.1" + resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +urix@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz" + integrity sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg== + +url@^0.11.0: + version "0.11.0" + resolved "https://registry.npmjs.org/url/-/url-0.11.0.tgz" + integrity sha512-kbailJa29QrtXnxgq+DdCEGlbTeYM2eJUxsz6vjZavrCYPMIFHMKQmSKYAIuUK2i7hgPm28a8piX5NTUtM/LKQ== + dependencies: + punycode "1.3.2" + querystring "0.2.0" + +use@^3.1.0: + version "3.1.1" + resolved "https://registry.npmjs.org/use/-/use-3.1.1.tgz" + integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ== + +utf-8-validate@5.0.7: + version "5.0.7" + resolved "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.7.tgz" + integrity sha512-vLt1O5Pp+flcArHGIyKEQq883nBt8nN8tVBcoL0qUXj2XT1n7p70yGIq2VK98I5FdZ1YHc0wk/koOnHjnXWk1Q== + dependencies: + node-gyp-build "^4.3.0" + +utf8@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz" + integrity sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ== + +util-deprecate@^1.0.1, util-deprecate@~1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz" + integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== + +uuid@2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz" + integrity sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg== + +uuid@^3.3.2: + version "3.4.0" + resolved "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz" + integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== + +uuid@^7.0.3: + version "7.0.3" + resolved "https://registry.npmjs.org/uuid/-/uuid-7.0.3.tgz" + integrity sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg== + +uuid@^8.3.2: + version "8.3.2" + resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz" + integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg== + +v8-compile-cache-lib@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz" + integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== + +validate-npm-package-license@^3.0.1: + version "3.0.4" + resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz" + integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew== + dependencies: + spdx-correct "^3.0.0" + spdx-expression-parse "^3.0.0" + +verror@1.10.0: + version "1.10.0" + resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz" + integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw== + dependencies: + assert-plus "^1.0.0" + core-util-is "1.0.2" + extsprintf "^1.2.0" + +wcwidth@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz" + integrity sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg== + dependencies: + defaults "^1.0.3" + +web3-utils@^1.3.6: + version "1.10.4" + resolved "https://registry.yarnpkg.com/web3-utils/-/web3-utils-1.10.4.tgz#0daee7d6841641655d8b3726baf33b08eda1cbec" + integrity sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A== + dependencies: + "@ethereumjs/util" "^8.1.0" + bn.js "^5.2.1" + ethereum-bloom-filters "^1.0.6" + ethereum-cryptography "^2.1.2" + ethjs-unit "0.1.6" + number-to-bn "1.7.0" + randombytes "^2.1.0" + utf8 "3.0.0" + +webidl-conversions@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz" + integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== + +whatwg-url@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz" + integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== + dependencies: + tr46 "~0.0.3" + webidl-conversions "^3.0.0" + +which-boxed-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz" + integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg== + dependencies: + is-bigint "^1.0.1" + is-boolean-object "^1.1.0" + is-number-object "^1.0.4" + is-string "^1.0.5" + is-symbol "^1.0.3" + +which-module@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz" + integrity sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q== + +which-pm@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/which-pm/-/which-pm-2.0.0.tgz" + integrity sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w== + dependencies: + load-yaml-file "^0.2.0" + path-exists "^4.0.0" + +which-typed-array@^1.1.14, which-typed-array@^1.1.15: + version "1.1.15" + resolved "https://registry.yarnpkg.com/which-typed-array/-/which-typed-array-1.1.15.tgz#264859e9b11a649b388bfaaf4f767df1f779b38d" + integrity sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA== + dependencies: + available-typed-arrays "^1.0.7" + call-bind "^1.0.7" + for-each "^0.3.3" + gopd "^1.0.1" + has-tostringtag "^1.0.2" + +which-typed-array@^1.1.9: + version "1.1.9" + resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz" + integrity sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA== + dependencies: + available-typed-arrays "^1.0.5" + call-bind "^1.0.2" + for-each "^0.3.3" + gopd "^1.0.1" + has-tostringtag "^1.0.0" + is-typed-array "^1.1.10" + +which@1.3.1, which@^1.1.1, which@^1.2.9, which@^1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz" + integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ== + dependencies: + isexe "^2.0.0" + +which@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +wide-align@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz" + integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA== + dependencies: + string-width "^1.0.2 || 2" + +word-wrap@^1.2.3, word-wrap@~1.2.3: + version "1.2.3" + resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz" + integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== + +wordwrap@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz" + integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q== + +wordwrapjs@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-4.0.1.tgz" + integrity sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA== + dependencies: + reduce-flatten "^2.0.0" + typical "^5.2.0" + +workerpool@6.2.1: + version "6.2.1" + resolved "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz" + integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw== + +wrap-ansi@^5.1.0: + version "5.1.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz" + integrity sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q== + dependencies: + ansi-styles "^3.2.0" + string-width "^3.0.0" + strip-ansi "^5.0.0" + +wrap-ansi@^6.2.0: + version "6.2.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz" + integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz" + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== + +ws@7.4.6: + version "7.4.6" + resolved "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz" + integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A== + +ws@^7.4.6: + version "7.5.9" + resolved "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz" + integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q== + +xmlhttprequest@1.8.0: + version "1.8.0" + resolved "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz" + integrity sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA== + +xtend@^4.0.1, xtend@^4.0.2, xtend@~4.0.0: + version "4.0.2" + resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz" + integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== + +y18n@^4.0.0: + version "4.0.3" + resolved "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz" + integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yallist@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz" + integrity sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A== + +yallist@^3.0.2: + version "3.1.1" + resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz" + integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yargs-parser@13.1.2, yargs-parser@^13.1.2: + version "13.1.2" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz" + integrity sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg== + dependencies: + camelcase "^5.0.0" + decamelize "^1.2.0" + +yargs-parser@20.2.4: + version "20.2.4" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz" + integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA== + +yargs-parser@^18.1.2, yargs-parser@^18.1.3: + version "18.1.3" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-18.1.3.tgz" + integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ== + dependencies: + camelcase "^5.0.0" + decamelize "^1.2.0" + +yargs-parser@^20.2.2, yargs-parser@^20.2.9: + version "20.2.9" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz" + integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs-unparser@1.6.0: + version "1.6.0" + resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz" + integrity sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw== + dependencies: + flat "^4.1.0" + lodash "^4.17.15" + yargs "^13.3.0" + +yargs-unparser@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz" + integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA== + dependencies: + camelcase "^6.0.0" + decamelize "^4.0.0" + flat "^5.0.2" + is-plain-obj "^2.1.0" + +yargs@13.3.2, yargs@^13.3.0: + version "13.3.2" + resolved "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz" + integrity sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw== + dependencies: + cliui "^5.0.0" + find-up "^3.0.0" + get-caller-file "^2.0.1" + require-directory "^2.1.1" + require-main-filename "^2.0.0" + set-blocking "^2.0.0" + string-width "^3.0.0" + which-module "^2.0.0" + y18n "^4.0.0" + yargs-parser "^13.1.2" + +yargs@16.2.0: + version "16.2.0" + resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz" + integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== + dependencies: + cliui "^7.0.2" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.0" + y18n "^5.0.5" + yargs-parser "^20.2.2" + +yargs@^15.1.0: + version "15.4.1" + resolved "https://registry.npmjs.org/yargs/-/yargs-15.4.1.tgz" + integrity sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A== + dependencies: + cliui "^6.0.0" + decamelize "^1.2.0" + find-up "^4.1.0" + get-caller-file "^2.0.1" + require-directory "^2.1.1" + require-main-filename "^2.0.0" + set-blocking "^2.0.0" + string-width "^4.2.0" + which-module "^2.0.0" + y18n "^4.0.0" + yargs-parser "^18.1.2" + +yargs@^17.7.1: + version "17.7.1" + resolved "https://registry.npmjs.org/yargs/-/yargs-17.7.1.tgz" + integrity sha512-cwiTb08Xuv5fqF4AovYacTFNxk62th7LKJ6BL9IGUpTJrWoU7/7WdQGTP2SjKf1dUNBGzDd28p/Yfs/GI6JrLw== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" + +yn@3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz" + integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== + +yn@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/yn/-/yn-2.0.0.tgz" + integrity sha512-uTv8J/wiWTgUTg+9vLTi//leUl5vDQS6uii/emeTb2ssY7vl6QWf2fFbIIGjnhjvbdKlU0ed7QPgY1htTC86jQ== + +yocto-queue@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz" + integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== From b9e5bfd49a1ca8d8965826bd9bf461ea82d0ce85 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 27 Jun 2024 15:03:58 +0100 Subject: [PATCH 20/86] feat: inbound evm prototype (#178) Co-authored-by: lumtis --- .../prototypes/{ => evm}/ERC20CustodyNew.sol | 4 +- .../{Gateway.sol => evm/GatewayEVM.sol} | 64 +- .../GatewayEVMUpgradeTest.sol} | 44 +- contracts/prototypes/{ => evm}/Receiver.sol | 0 contracts/prototypes/{ => evm}/TestERC20.sol | 0 contracts/prototypes/{ => evm}/interfaces.sol | 6 +- .../erc20custodynew.sol/erc20custodynew.go | 4 +- .../evm/gatewayevm.sol/gatewayevm.go | 1921 +++++++++++++++++ .../gatewayevmupgradetest.go | 1829 ++++++++++++++++ .../evm/interfaces.sol/igatewayevm.go | 265 +++ .../{ => evm}/receiver.sol/receiver.go | 2 +- .../{ => evm}/testerc20.sol/testerc20.go | 2 +- .../prototypes/gateway.sol/gateway.go | 1475 ------------- .../gatewayupgradetest.go | 1475 ------------- .../prototypes/interfaces.sol/igateway.go | 223 -- test/prototypes/GatewayEVM.spec.ts | 311 +++ ...swap.spec.ts => GatewayEVMUniswap.spec.ts} | 15 +- ...rade.spec.ts => GatewayEVMUpgrade.spec.ts} | 23 +- test/prototypes/GatewayIntegration.spec.ts | 126 -- .../contracts/prototypes/Gateway.ts | 151 +- .../prototypes/evm/ERC20CustodyNew.ts | 245 +++ .../contracts/prototypes/evm/Gateway.ts | 704 ++++++ .../contracts/prototypes/evm/GatewayEVM.ts | 852 ++++++++ .../prototypes/evm/GatewayEVMUpgradeTest.ts | 704 ++++++ .../prototypes/evm/GatewayUpgradeTest.ts | 704 ++++++ .../contracts/prototypes/evm/Receiver.ts | 336 +++ .../contracts/prototypes/evm/TestERC20.ts | 501 +++++ .../contracts/prototypes/evm/index.ts | 10 + .../prototypes/evm/interfaces.sol/IGateway.ts | 250 +++ .../evm/interfaces.sol/IGatewayEVM.ts | 250 +++ .../prototypes/evm/interfaces.sol/index.ts | 4 + typechain-types/contracts/prototypes/index.ts | 9 +- .../prototypes/ERC20CustodyNew__factory.ts | 2 +- .../contracts/prototypes/Gateway__factory.ts | 188 +- .../evm/ERC20CustodyNew__factory.ts | 196 ++ .../evm/GatewayEVMUpgradeTest__factory.ts | 497 +++++ .../prototypes/evm/GatewayEVM__factory.ts | 575 +++++ .../evm/GatewayUpgradeTest__factory.ts | 488 +++++ .../prototypes/evm/Gateway__factory.ts | 488 +++++ .../prototypes/evm/Receiver__factory.ts | 251 +++ .../prototypes/evm/TestERC20__factory.ts | 371 ++++ .../contracts/prototypes/evm/index.ts | 9 + .../interfaces.sol/IGatewayEVM__factory.ts | 125 ++ .../evm/interfaces.sol/IGateway__factory.ts | 125 ++ .../prototypes/evm/interfaces.sol/index.ts | 4 + .../factories/contracts/prototypes/index.ts | 7 +- typechain-types/hardhat.d.ts | 24 +- typechain-types/index.ts | 24 +- 48 files changed, 12512 insertions(+), 3371 deletions(-) rename contracts/prototypes/{ => evm}/ERC20CustodyNew.sol (95%) rename contracts/prototypes/{Gateway.sol => evm/GatewayEVM.sol} (54%) rename contracts/prototypes/{GatewayUpgradeTest.sol => evm/GatewayEVMUpgradeTest.sol} (66%) rename contracts/prototypes/{ => evm}/Receiver.sol (100%) rename contracts/prototypes/{ => evm}/TestERC20.sol (100%) rename contracts/prototypes/{ => evm}/interfaces.sol (62%) rename pkg/contracts/prototypes/{ => evm}/erc20custodynew.sol/erc20custodynew.go (96%) create mode 100644 pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go create mode 100644 pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go create mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go rename pkg/contracts/prototypes/{ => evm}/receiver.sol/receiver.go (99%) rename pkg/contracts/prototypes/{ => evm}/testerc20.sol/testerc20.go (99%) delete mode 100644 pkg/contracts/prototypes/gateway.sol/gateway.go delete mode 100644 pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go delete mode 100644 pkg/contracts/prototypes/interfaces.sol/igateway.go create mode 100644 test/prototypes/GatewayEVM.spec.ts rename test/prototypes/{GatewayUniswap.spec.ts => GatewayEVMUniswap.spec.ts} (89%) rename test/prototypes/{GatewayUpgrade.spec.ts => GatewayEVMUpgrade.spec.ts} (75%) delete mode 100644 test/prototypes/GatewayIntegration.spec.ts create mode 100644 typechain-types/contracts/prototypes/evm/ERC20CustodyNew.ts create mode 100644 typechain-types/contracts/prototypes/evm/Gateway.ts create mode 100644 typechain-types/contracts/prototypes/evm/GatewayEVM.ts create mode 100644 typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts create mode 100644 typechain-types/contracts/prototypes/evm/GatewayUpgradeTest.ts create mode 100644 typechain-types/contracts/prototypes/evm/Receiver.ts create mode 100644 typechain-types/contracts/prototypes/evm/TestERC20.ts create mode 100644 typechain-types/contracts/prototypes/evm/index.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/IGateway.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayUpgradeTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/Gateway__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/TestERC20__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGateway__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts diff --git a/contracts/prototypes/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol similarity index 95% rename from contracts/prototypes/ERC20CustodyNew.sol rename to contracts/prototypes/evm/ERC20CustodyNew.sol index 803eec8e..2dbf54a4 100644 --- a/contracts/prototypes/ERC20CustodyNew.sol +++ b/contracts/prototypes/evm/ERC20CustodyNew.sol @@ -8,13 +8,13 @@ import "./interfaces.sol"; // This version include a functionality allowing to call a contract // ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract contract ERC20CustodyNew { - IGateway public gateway; + IGatewayEVM public gateway; event Withdraw(address indexed token, address indexed to, uint256 amount); event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data); constructor(address _gateway) { - gateway = IGateway(_gateway); + gateway = IGatewayEVM(_gateway); } // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call diff --git a/contracts/prototypes/Gateway.sol b/contracts/prototypes/evm/GatewayEVM.sol similarity index 54% rename from contracts/prototypes/Gateway.sol rename to contracts/prototypes/evm/GatewayEVM.sol index 04d9d8fb..43bf4046 100644 --- a/contracts/prototypes/Gateway.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -7,24 +7,36 @@ import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; -// The Gateway contract is the endpoint to call smart contracts on external chains +// The GatewayEVM contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances -contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); + error DepositFailed(); + error InsufficientETHAmount(); + error InsufficientERC20Amount(); + error ZeroAddress(); address public custody; + address public tssAddress; event Executed(address indexed destination, uint256 value, bytes data); event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); + event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); + event Call(address indexed sender, address indexed receiver, bytes payload); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } - function initialize() public initializer { + function initialize(address _tssAddress) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); + + if (_tssAddress == address(0)) { + revert ZeroAddress(); + } + tssAddress = _tssAddress; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -61,6 +73,7 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens + IERC20(token).approve(to, 0); IERC20(token).approve(to, amount); // Execute the call on the target contract @@ -80,6 +93,51 @@ contract Gateway is Initializable, OwnableUpgradeable, UUPSUpgradeable { return result; } + // Deposit ETH to tss + function deposit(address receiver) external payable { + if (msg.value == 0) revert InsufficientETHAmount(); + (bool deposited, ) = tssAddress.call{value: msg.value}(""); + + if (deposited == false) { + revert DepositFailed(); + } + + emit Deposit(msg.sender, receiver, msg.value, address(0), ""); + } + + // Deposit ERC20 tokens to custody + function deposit(address receiver, uint256 amount, address asset) external { + if (amount == 0) revert InsufficientERC20Amount(); + IERC20(asset).transferFrom(msg.sender, address(custody), amount); + + emit Deposit(msg.sender, receiver, amount, asset, ""); + } + + // Deposit ETH to tss and call an omnichain smart contract + function depositAndCall(address receiver, bytes calldata payload) external payable { + if (msg.value == 0) revert InsufficientETHAmount(); + (bool deposited, ) = tssAddress.call{value: msg.value}(""); + + if (deposited == false) { + revert DepositFailed(); + } + + emit Deposit(msg.sender, receiver, msg.value, address(0), payload); + } + + // Deposit ERC20 tokens to custody and call an omnichain smart contract + function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { + if (amount == 0) revert InsufficientERC20Amount(); + IERC20(asset).transferFrom(msg.sender, address(custody), amount); + + emit Deposit(msg.sender, receiver, amount, asset, payload); + } + + // Call an omnichain smart contract without asset transfer + function call(address receiver, bytes calldata payload) external { + emit Call(msg.sender, receiver, payload); + } + function setCustody(address _custody) external { custody = _custody; } diff --git a/contracts/prototypes/GatewayUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol similarity index 66% rename from contracts/prototypes/GatewayUpgradeTest.sol rename to contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index 0a827536..dc58cb83 100644 --- a/contracts/prototypes/GatewayUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -7,25 +7,36 @@ import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; -// NOTE: Purpose of this contract is to test upgrade process, the only difference should be event names +// NOTE: Purpose of this contract is to test upgrade process, the only difference should be name of Executed event // The Gateway contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances -contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { error ExecutionFailed(); + error SendFailed(); + error InsufficientETHAmount(); + error ZeroAddress(); address public custody; + address public tssAddress; event ExecutedV2(address indexed destination, uint256 value, bytes data); - event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data); + event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); + event SendERC20(bytes recipient, address indexed asset, uint256 amount); + event Send(bytes recipient, uint256 amount); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } - function initialize() public initializer { + function initialize(address _tssAddress) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); + + if (_tssAddress == address(0)) { + revert ZeroAddress(); + } + tssAddress = _tssAddress; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -62,6 +73,7 @@ contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeabl bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens + IERC20(token).approve(to, 0); IERC20(token).approve(to, amount); // Execute the call on the target contract @@ -76,11 +88,33 @@ contract GatewayUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeabl IERC20(token).transfer(address(custody), remainingBalance); } - emit ExecutedWithERC20V2(token, to, amount, data); + emit ExecutedWithERC20(token, to, amount, data); return result; } + // Transfer specified token amount to ERC20Custody and emits event + function sendERC20(bytes calldata recipient, address token, uint256 amount) external { + IERC20(token).transferFrom(msg.sender, address(custody), amount); + + emit SendERC20(recipient, token, amount); + } + + // Transfer specified ETH amount to TSS address and emits event + function send(bytes calldata recipient, uint256 amount) external payable { + if (msg.value == 0) { + revert InsufficientETHAmount(); + } + + (bool sent, ) = tssAddress.call{value: msg.value}(""); + + if (sent == false) { + revert SendFailed(); + } + + emit Send(recipient, msg.value); + } + function setCustody(address _custody) external { custody = _custody; } diff --git a/contracts/prototypes/Receiver.sol b/contracts/prototypes/evm/Receiver.sol similarity index 100% rename from contracts/prototypes/Receiver.sol rename to contracts/prototypes/evm/Receiver.sol diff --git a/contracts/prototypes/TestERC20.sol b/contracts/prototypes/evm/TestERC20.sol similarity index 100% rename from contracts/prototypes/TestERC20.sol rename to contracts/prototypes/evm/TestERC20.sol diff --git a/contracts/prototypes/interfaces.sol b/contracts/prototypes/evm/interfaces.sol similarity index 62% rename from contracts/prototypes/interfaces.sol rename to contracts/prototypes/evm/interfaces.sol index 58a474ae..38d006c8 100644 --- a/contracts/prototypes/interfaces.sol +++ b/contracts/prototypes/evm/interfaces.sol @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; -interface IGateway { +interface IGatewayEVM { function executeWithERC20( address token, address to, @@ -10,4 +10,8 @@ interface IGateway { ) external returns (bytes memory); function execute(address destination, bytes calldata data) external payable returns (bytes memory); + + function sendERC20(bytes calldata recipient, address asset, uint256 amount) external; + + function send(bytes calldata recipient, uint256 amount) external payable; } \ No newline at end of file diff --git a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go similarity index 96% rename from pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go rename to pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index 84fac379..9f42a416 100644 --- a/pkg/contracts/prototypes/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go @@ -31,8 +31,8 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGateway\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go new file mode 100644 index 00000000..937bc51f --- /dev/null +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -0,0 +1,1921 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayevm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. +var GatewayEVMMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMMetaData.ABI instead. +var GatewayEVMABI = GatewayEVMMetaData.ABI + +// GatewayEVMBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMMetaData.Bin instead. +var GatewayEVMBin = GatewayEVMMetaData.Bin + +// DeployGatewayEVM deploys a new Ethereum contract, binding an instance of GatewayEVM to it. +func DeployGatewayEVM(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVM, error) { + parsed, err := GatewayEVMMetaData.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(GatewayEVMBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayEVM{GatewayEVMCaller: GatewayEVMCaller{contract: contract}, GatewayEVMTransactor: GatewayEVMTransactor{contract: contract}, GatewayEVMFilterer: GatewayEVMFilterer{contract: contract}}, nil +} + +// GatewayEVM is an auto generated Go binding around an Ethereum contract. +type GatewayEVM struct { + GatewayEVMCaller // Read-only binding to the contract + GatewayEVMTransactor // Write-only binding to the contract + GatewayEVMFilterer // Log filterer for contract events +} + +// GatewayEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayEVMCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayEVMTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayEVMFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayEVMSession struct { + Contract *GatewayEVM // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayEVMCallerSession struct { + Contract *GatewayEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayEVMTransactorSession struct { + Contract *GatewayEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayEVMRaw struct { + Contract *GatewayEVM // Generic contract binding to access the raw methods on +} + +// GatewayEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayEVMCallerRaw struct { + Contract *GatewayEVMCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayEVMTransactorRaw struct { + Contract *GatewayEVMTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayEVM creates a new instance of GatewayEVM, bound to a specific deployed contract. +func NewGatewayEVM(address common.Address, backend bind.ContractBackend) (*GatewayEVM, error) { + contract, err := bindGatewayEVM(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayEVM{GatewayEVMCaller: GatewayEVMCaller{contract: contract}, GatewayEVMTransactor: GatewayEVMTransactor{contract: contract}, GatewayEVMFilterer: GatewayEVMFilterer{contract: contract}}, nil +} + +// NewGatewayEVMCaller creates a new read-only instance of GatewayEVM, bound to a specific deployed contract. +func NewGatewayEVMCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMCaller, error) { + contract, err := bindGatewayEVM(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayEVMCaller{contract: contract}, nil +} + +// NewGatewayEVMTransactor creates a new write-only instance of GatewayEVM, bound to a specific deployed contract. +func NewGatewayEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMTransactor, error) { + contract, err := bindGatewayEVM(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayEVMTransactor{contract: contract}, nil +} + +// NewGatewayEVMFilterer creates a new log filterer instance of GatewayEVM, bound to a specific deployed contract. +func NewGatewayEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMFilterer, error) { + contract, err := bindGatewayEVM(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayEVMFilterer{contract: contract}, nil +} + +// bindGatewayEVM binds a generic wrapper to an already deployed contract. +func bindGatewayEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayEVMMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVM *GatewayEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVM.Contract.GatewayEVMCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVM *GatewayEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVM.Contract.GatewayEVMTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVM *GatewayEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVM.Contract.GatewayEVMTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVM *GatewayEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVM.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVM *GatewayEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVM.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVM *GatewayEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVM.Contract.contract.Transact(opts, method, params...) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "custody") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVM *GatewayEVMSession) Custody() (common.Address, error) { + return _GatewayEVM.Contract.Custody(&_GatewayEVM.CallOpts) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) Custody() (common.Address, error) { + return _GatewayEVM.Contract.Custody(&_GatewayEVM.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVM *GatewayEVMSession) Owner() (common.Address, error) { + return _GatewayEVM.Contract.Owner(&_GatewayEVM.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) Owner() (common.Address, error) { + return _GatewayEVM.Contract.Owner(&_GatewayEVM.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVM *GatewayEVMCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVM *GatewayEVMSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVM.Contract.ProxiableUUID(&_GatewayEVM.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVM *GatewayEVMCallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVM.Contract.ProxiableUUID(&_GatewayEVM.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "tssAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVM *GatewayEVMSession) TssAddress() (common.Address, error) { + return _GatewayEVM.Contract.TssAddress(&_GatewayEVM.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) TssAddress() (common.Address, error) { + return _GatewayEVM.Contract.TssAddress(&_GatewayEVM.CallOpts) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVM *GatewayEVMTransactor) Call(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "call", receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVM *GatewayEVMSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.Call(&_GatewayEVM.TransactOpts, receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.Call(&_GatewayEVM.TransactOpts, receiver, payload) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVM *GatewayEVMTransactor) Deposit(opts *bind.TransactOpts, receiver common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "deposit", receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVM *GatewayEVMSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Deposit(&_GatewayEVM.TransactOpts, receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Deposit(&_GatewayEVM.TransactOpts, receiver) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVM *GatewayEVMTransactor) Deposit0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "deposit0", receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVM *GatewayEVMSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Deposit0(&_GatewayEVM.TransactOpts, receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Deposit0(&_GatewayEVM.TransactOpts, receiver, amount, asset) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVM *GatewayEVMTransactor) DepositAndCall(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "depositAndCall", receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVM *GatewayEVMSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.DepositAndCall(&_GatewayEVM.TransactOpts, receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVM *GatewayEVMTransactorSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.DepositAndCall(&_GatewayEVM.TransactOpts, receiver, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVM *GatewayEVMTransactor) DepositAndCall0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "depositAndCall0", receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVM *GatewayEVMSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.DepositAndCall0(&_GatewayEVM.TransactOpts, receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.DepositAndCall0(&_GatewayEVM.TransactOpts, receiver, amount, asset, payload) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVM *GatewayEVMTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVM *GatewayEVMSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.Execute(&_GatewayEVM.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVM *GatewayEVMTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.Execute(&_GatewayEVM.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVM *GatewayEVMTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVM *GatewayEVMSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.ExecuteWithERC20(&_GatewayEVM.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVM *GatewayEVMTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.ExecuteWithERC20(&_GatewayEVM.TransactOpts, token, to, amount, data) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVM *GatewayEVMTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVM *GatewayEVMSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVM.Contract.RenounceOwnership(&_GatewayEVM.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVM *GatewayEVMTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVM.Contract.RenounceOwnership(&_GatewayEVM.TransactOpts) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVM *GatewayEVMTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVM *GatewayEVMSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.SetCustody(&_GatewayEVM.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.SetCustody(&_GatewayEVM.TransactOpts, _custody) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVM *GatewayEVMTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVM *GatewayEVMSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.TransferOwnership(&_GatewayEVM.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.TransferOwnership(&_GatewayEVM.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVM *GatewayEVMTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVM *GatewayEVMSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.UpgradeTo(&_GatewayEVM.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.UpgradeTo(&_GatewayEVM.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVM *GatewayEVMTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVM *GatewayEVMSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.UpgradeToAndCall(&_GatewayEVM.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVM *GatewayEVMTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVM.Contract.UpgradeToAndCall(&_GatewayEVM.TransactOpts, newImplementation, data) +} + +// GatewayEVMAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayEVM contract. +type GatewayEVMAdminChangedIterator struct { + Event *GatewayEVMAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMAdminChanged represents a AdminChanged event raised by the GatewayEVM contract. +type GatewayEVMAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVM *GatewayEVMFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayEVMAdminChangedIterator, error) { + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayEVMAdminChangedIterator{contract: _GatewayEVM.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVM *GatewayEVMFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayEVMAdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMAdminChanged) + if err := _GatewayEVM.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVM *GatewayEVMFilterer) ParseAdminChanged(log types.Log) (*GatewayEVMAdminChanged, error) { + event := new(GatewayEVMAdminChanged) + if err := _GatewayEVM.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayEVM contract. +type GatewayEVMBeaconUpgradedIterator struct { + Event *GatewayEVMBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayEVM contract. +type GatewayEVMBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVM *GatewayEVMFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayEVMBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayEVMBeaconUpgradedIterator{contract: _GatewayEVM.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVM *GatewayEVMFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMBeaconUpgraded) + if err := _GatewayEVM.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVM *GatewayEVMFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayEVMBeaconUpgraded, error) { + event := new(GatewayEVMBeaconUpgraded) + if err := _GatewayEVM.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVM contract. +type GatewayEVMCallIterator struct { + Event *GatewayEVMCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMCall represents a Call event raised by the GatewayEVM contract. +type GatewayEVMCall struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMCallIterator{contract: _GatewayEVM.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMCall) + if err := _GatewayEVM.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) ParseCall(log types.Log) (*GatewayEVMCall, error) { + event := new(GatewayEVMCall) + if err := _GatewayEVM.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVM contract. +type GatewayEVMDepositIterator struct { + Event *GatewayEVMDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMDeposit represents a Deposit event raised by the GatewayEVM contract. +type GatewayEVMDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMDepositIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMDepositIterator{contract: _GatewayEVM.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMDeposit) + if err := _GatewayEVM.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVM *GatewayEVMFilterer) ParseDeposit(log types.Log) (*GatewayEVMDeposit, error) { + event := new(GatewayEVMDeposit) + if err := _GatewayEVM.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVM contract. +type GatewayEVMExecutedIterator struct { + Event *GatewayEVMExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMExecuted represents a Executed event raised by the GatewayEVM contract. +type GatewayEVMExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &GatewayEVMExecutedIterator{contract: _GatewayEVM.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMExecuted) + if err := _GatewayEVM.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) ParseExecuted(log types.Log) (*GatewayEVMExecuted, error) { + event := new(GatewayEVMExecuted) + if err := _GatewayEVM.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVM contract. +type GatewayEVMExecutedWithERC20Iterator struct { + Event *GatewayEVMExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVM contract. +type GatewayEVMExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayEVMExecutedWithERC20Iterator{contract: _GatewayEVM.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMExecutedWithERC20) + if err := _GatewayEVM.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVM *GatewayEVMFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMExecutedWithERC20, error) { + event := new(GatewayEVMExecutedWithERC20) + if err := _GatewayEVM.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVM contract. +type GatewayEVMInitializedIterator struct { + Event *GatewayEVMInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMInitialized represents a Initialized event raised by the GatewayEVM contract. +type GatewayEVMInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVM *GatewayEVMFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMInitializedIterator, error) { + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayEVMInitializedIterator{contract: _GatewayEVM.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVM *GatewayEVMFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMInitialized) (event.Subscription, error) { + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMInitialized) + if err := _GatewayEVM.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVM *GatewayEVMFilterer) ParseInitialized(log types.Log) (*GatewayEVMInitialized, error) { + event := new(GatewayEVMInitialized) + if err := _GatewayEVM.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVM contract. +type GatewayEVMOwnershipTransferredIterator struct { + Event *GatewayEVMOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVM contract. +type GatewayEVMOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVM *GatewayEVMFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMOwnershipTransferredIterator, 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 := _GatewayEVM.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayEVMOwnershipTransferredIterator{contract: _GatewayEVM.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVM *GatewayEVMFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMOwnershipTransferred, 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 := _GatewayEVM.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMOwnershipTransferred) + if err := _GatewayEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVM *GatewayEVMFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMOwnershipTransferred, error) { + event := new(GatewayEVMOwnershipTransferred) + if err := _GatewayEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayEVM contract. +type GatewayEVMUpgradedIterator struct { + Event *GatewayEVMUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgraded represents a Upgraded event raised by the GatewayEVM contract. +type GatewayEVMUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVM *GatewayEVMFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayEVMUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVM.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradedIterator{contract: _GatewayEVM.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVM *GatewayEVMFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVM.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgraded) + if err := _GatewayEVM.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVM *GatewayEVMFilterer) ParseUpgraded(log types.Log) (*GatewayEVMUpgraded, error) { + event := new(GatewayEVMUpgraded) + if err := _GatewayEVM.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go new file mode 100644 index 00000000..68b06e1e --- /dev/null +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -0,0 +1,1829 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayevmupgradetest + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. +var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SendFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Send\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SendERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMUpgradeTestMetaData.ABI instead. +var GatewayEVMUpgradeTestABI = GatewayEVMUpgradeTestMetaData.ABI + +// GatewayEVMUpgradeTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMUpgradeTestMetaData.Bin instead. +var GatewayEVMUpgradeTestBin = GatewayEVMUpgradeTestMetaData.Bin + +// DeployGatewayEVMUpgradeTest deploys a new Ethereum contract, binding an instance of GatewayEVMUpgradeTest to it. +func DeployGatewayEVMUpgradeTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVMUpgradeTest, error) { + parsed, err := GatewayEVMUpgradeTestMetaData.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(GatewayEVMUpgradeTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayEVMUpgradeTest{GatewayEVMUpgradeTestCaller: GatewayEVMUpgradeTestCaller{contract: contract}, GatewayEVMUpgradeTestTransactor: GatewayEVMUpgradeTestTransactor{contract: contract}, GatewayEVMUpgradeTestFilterer: GatewayEVMUpgradeTestFilterer{contract: contract}}, nil +} + +// GatewayEVMUpgradeTest is an auto generated Go binding around an Ethereum contract. +type GatewayEVMUpgradeTest struct { + GatewayEVMUpgradeTestCaller // Read-only binding to the contract + GatewayEVMUpgradeTestTransactor // Write-only binding to the contract + GatewayEVMUpgradeTestFilterer // Log filterer for contract events +} + +// GatewayEVMUpgradeTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayEVMUpgradeTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMUpgradeTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayEVMUpgradeTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMUpgradeTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayEVMUpgradeTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMUpgradeTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayEVMUpgradeTestSession struct { + Contract *GatewayEVMUpgradeTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMUpgradeTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayEVMUpgradeTestCallerSession struct { + Contract *GatewayEVMUpgradeTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayEVMUpgradeTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayEVMUpgradeTestTransactorSession struct { + Contract *GatewayEVMUpgradeTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMUpgradeTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayEVMUpgradeTestRaw struct { + Contract *GatewayEVMUpgradeTest // Generic contract binding to access the raw methods on +} + +// GatewayEVMUpgradeTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayEVMUpgradeTestCallerRaw struct { + Contract *GatewayEVMUpgradeTestCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayEVMUpgradeTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayEVMUpgradeTestTransactorRaw struct { + Contract *GatewayEVMUpgradeTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayEVMUpgradeTest creates a new instance of GatewayEVMUpgradeTest, bound to a specific deployed contract. +func NewGatewayEVMUpgradeTest(address common.Address, backend bind.ContractBackend) (*GatewayEVMUpgradeTest, error) { + contract, err := bindGatewayEVMUpgradeTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTest{GatewayEVMUpgradeTestCaller: GatewayEVMUpgradeTestCaller{contract: contract}, GatewayEVMUpgradeTestTransactor: GatewayEVMUpgradeTestTransactor{contract: contract}, GatewayEVMUpgradeTestFilterer: GatewayEVMUpgradeTestFilterer{contract: contract}}, nil +} + +// NewGatewayEVMUpgradeTestCaller creates a new read-only instance of GatewayEVMUpgradeTest, bound to a specific deployed contract. +func NewGatewayEVMUpgradeTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMUpgradeTestCaller, error) { + contract, err := bindGatewayEVMUpgradeTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestCaller{contract: contract}, nil +} + +// NewGatewayEVMUpgradeTestTransactor creates a new write-only instance of GatewayEVMUpgradeTest, bound to a specific deployed contract. +func NewGatewayEVMUpgradeTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMUpgradeTestTransactor, error) { + contract, err := bindGatewayEVMUpgradeTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestTransactor{contract: contract}, nil +} + +// NewGatewayEVMUpgradeTestFilterer creates a new log filterer instance of GatewayEVMUpgradeTest, bound to a specific deployed contract. +func NewGatewayEVMUpgradeTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMUpgradeTestFilterer, error) { + contract, err := bindGatewayEVMUpgradeTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestFilterer{contract: contract}, nil +} + +// bindGatewayEVMUpgradeTest binds a generic wrapper to an already deployed contract. +func bindGatewayEVMUpgradeTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayEVMUpgradeTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMUpgradeTest.Contract.GatewayEVMUpgradeTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.GatewayEVMUpgradeTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.GatewayEVMUpgradeTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMUpgradeTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.contract.Transact(opts, method, params...) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "custody") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Custody() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Custody(&_GatewayEVMUpgradeTest.CallOpts) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) Custody() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Custody(&_GatewayEVMUpgradeTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Owner() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Owner(&_GatewayEVMUpgradeTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) Owner() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Owner(&_GatewayEVMUpgradeTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVMUpgradeTest.Contract.ProxiableUUID(&_GatewayEVMUpgradeTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVMUpgradeTest.Contract.ProxiableUUID(&_GatewayEVMUpgradeTest.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "tssAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) TssAddress() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.TssAddress(&_GatewayEVMUpgradeTest.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) TssAddress() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.TssAddress(&_GatewayEVMUpgradeTest.CallOpts) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Execute(&_GatewayEVMUpgradeTest.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Execute(&_GatewayEVMUpgradeTest.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.ExecuteWithERC20(&_GatewayEVMUpgradeTest.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.ExecuteWithERC20(&_GatewayEVMUpgradeTest.TransactOpts, token, to, amount, data) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.RenounceOwnership(&_GatewayEVMUpgradeTest.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.RenounceOwnership(&_GatewayEVMUpgradeTest.TransactOpts) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "send", recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Send(&_GatewayEVMUpgradeTest.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Send(&_GatewayEVMUpgradeTest.TransactOpts, recipient, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "sendERC20", recipient, token, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SendERC20(&_GatewayEVMUpgradeTest.TransactOpts, recipient, token, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SendERC20(&_GatewayEVMUpgradeTest.TransactOpts, recipient, token, amount) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SetCustody(&_GatewayEVMUpgradeTest.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SetCustody(&_GatewayEVMUpgradeTest.TransactOpts, _custody) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.TransferOwnership(&_GatewayEVMUpgradeTest.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.TransferOwnership(&_GatewayEVMUpgradeTest.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.UpgradeTo(&_GatewayEVMUpgradeTest.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.UpgradeTo(&_GatewayEVMUpgradeTest.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.UpgradeToAndCall(&_GatewayEVMUpgradeTest.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.UpgradeToAndCall(&_GatewayEVMUpgradeTest.TransactOpts, newImplementation, data) +} + +// GatewayEVMUpgradeTestAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestAdminChangedIterator struct { + Event *GatewayEVMUpgradeTestAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestAdminChanged represents a AdminChanged event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestAdminChangedIterator, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestAdminChangedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestAdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestAdminChanged) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseAdminChanged(log types.Log) (*GatewayEVMUpgradeTestAdminChanged, error) { + event := new(GatewayEVMUpgradeTestAdminChanged) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestBeaconUpgradedIterator struct { + Event *GatewayEVMUpgradeTestBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayEVMUpgradeTestBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestBeaconUpgradedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestBeaconUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayEVMUpgradeTestBeaconUpgraded, error) { + event := new(GatewayEVMUpgradeTestBeaconUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedV2Iterator struct { + Event *GatewayEVMUpgradeTestExecutedV2 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedV2) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedV2 struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMUpgradeTestExecutedV2Iterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestExecutedV2Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil +} + +// WatchExecutedV2 is a free log subscription operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestExecutedV2) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", 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 +} + +// ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedV2(log types.Log) (*GatewayEVMUpgradeTestExecutedV2, error) { + event := new(GatewayEVMUpgradeTestExecutedV2) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedWithERC20Iterator struct { + Event *GatewayEVMUpgradeTestExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMUpgradeTestExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestExecutedWithERC20Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMUpgradeTestExecutedWithERC20, error) { + event := new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestInitializedIterator struct { + Event *GatewayEVMUpgradeTestInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestInitialized represents a Initialized event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestInitializedIterator, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestInitializedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestInitialized) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestInitialized) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseInitialized(log types.Log) (*GatewayEVMUpgradeTestInitialized, error) { + event := new(GatewayEVMUpgradeTestInitialized) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestOwnershipTransferredIterator struct { + Event *GatewayEVMUpgradeTestOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMUpgradeTestOwnershipTransferredIterator, 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 := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestOwnershipTransferredIterator{contract: _GatewayEVMUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestOwnershipTransferred, 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 := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMUpgradeTestOwnershipTransferred, error) { + event := new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestSendIterator struct { + Event *GatewayEVMUpgradeTestSend // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestSend) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestSendIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestSendIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestSend represents a Send event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestSend struct { + Recipient []byte + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSend is a free log retrieval operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// +// Solidity: event Send(bytes recipient, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestSendIterator, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Send") + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestSendIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Send", logs: logs, sub: sub}, nil +} + +// WatchSend is a free log subscription operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// +// Solidity: event Send(bytes recipient, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestSend) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Send") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestSend) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Send", 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 +} + +// ParseSend is a log parse operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// +// Solidity: event Send(bytes recipient, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseSend(log types.Log) (*GatewayEVMUpgradeTestSend, error) { + event := new(GatewayEVMUpgradeTestSend) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestSendERC20Iterator struct { + Event *GatewayEVMUpgradeTestSendERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestSendERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestSendERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestSendERC20 represents a SendERC20 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestSendERC20 struct { + Recipient []byte + Asset common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSendERC20 is a free log retrieval operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// +// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayEVMUpgradeTestSendERC20Iterator, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "SendERC20", assetRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestSendERC20Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "SendERC20", logs: logs, sub: sub}, nil +} + +// WatchSendERC20 is a free log subscription operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// +// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestSendERC20, asset []common.Address) (event.Subscription, error) { + + var assetRule []interface{} + for _, assetItem := range asset { + assetRule = append(assetRule, assetItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "SendERC20", assetRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestSendERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "SendERC20", 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 +} + +// ParseSendERC20 is a log parse operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// +// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseSendERC20(log types.Log) (*GatewayEVMUpgradeTestSendERC20, error) { + event := new(GatewayEVMUpgradeTestSendERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMUpgradeTestUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestUpgradedIterator struct { + Event *GatewayEVMUpgradeTestUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestUpgraded represents a Upgraded event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayEVMUpgradeTestUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestUpgradedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseUpgraded(log types.Log) (*GatewayEVMUpgradeTestUpgraded, error) { + event := new(GatewayEVMUpgradeTestUpgraded) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go new file mode 100644 index 00000000..def1e811 --- /dev/null +++ b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go @@ -0,0 +1,265 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayEVMMetaData contains all meta data concerning the IGatewayEVM contract. +var IGatewayEVMMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IGatewayEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayEVMMetaData.ABI instead. +var IGatewayEVMABI = IGatewayEVMMetaData.ABI + +// IGatewayEVM is an auto generated Go binding around an Ethereum contract. +type IGatewayEVM struct { + IGatewayEVMCaller // Read-only binding to the contract + IGatewayEVMTransactor // Write-only binding to the contract + IGatewayEVMFilterer // Log filterer for contract events +} + +// IGatewayEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayEVMCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayEVMTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayEVMFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayEVMSession struct { + Contract *IGatewayEVM // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayEVMCallerSession struct { + Contract *IGatewayEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayEVMTransactorSession struct { + Contract *IGatewayEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayEVMRaw struct { + Contract *IGatewayEVM // Generic contract binding to access the raw methods on +} + +// IGatewayEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayEVMCallerRaw struct { + Contract *IGatewayEVMCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayEVMTransactorRaw struct { + Contract *IGatewayEVMTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayEVM creates a new instance of IGatewayEVM, bound to a specific deployed contract. +func NewIGatewayEVM(address common.Address, backend bind.ContractBackend) (*IGatewayEVM, error) { + contract, err := bindIGatewayEVM(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayEVM{IGatewayEVMCaller: IGatewayEVMCaller{contract: contract}, IGatewayEVMTransactor: IGatewayEVMTransactor{contract: contract}, IGatewayEVMFilterer: IGatewayEVMFilterer{contract: contract}}, nil +} + +// NewIGatewayEVMCaller creates a new read-only instance of IGatewayEVM, bound to a specific deployed contract. +func NewIGatewayEVMCaller(address common.Address, caller bind.ContractCaller) (*IGatewayEVMCaller, error) { + contract, err := bindIGatewayEVM(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMCaller{contract: contract}, nil +} + +// NewIGatewayEVMTransactor creates a new write-only instance of IGatewayEVM, bound to a specific deployed contract. +func NewIGatewayEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayEVMTransactor, error) { + contract, err := bindIGatewayEVM(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMTransactor{contract: contract}, nil +} + +// NewIGatewayEVMFilterer creates a new log filterer instance of IGatewayEVM, bound to a specific deployed contract. +func NewIGatewayEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayEVMFilterer, error) { + contract, err := bindIGatewayEVM(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayEVMFilterer{contract: contract}, nil +} + +// bindIGatewayEVM binds a generic wrapper to an already deployed contract. +func bindIGatewayEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayEVMMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVM *IGatewayEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVM.Contract.IGatewayEVMCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVM *IGatewayEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVM.Contract.IGatewayEVMTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVM *IGatewayEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVM.Contract.IGatewayEVMTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVM *IGatewayEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVM.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVM *IGatewayEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVM.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVM *IGatewayEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVM.Contract.contract.Transact(opts, method, params...) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGatewayEVM *IGatewayEVMTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGatewayEVM *IGatewayEVMSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.Contract.Execute(&_IGatewayEVM.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_IGatewayEVM *IGatewayEVMTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.Contract.Execute(&_IGatewayEVM.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGatewayEVM *IGatewayEVMTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGatewayEVM *IGatewayEVMSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.Contract.ExecuteWithERC20(&_IGatewayEVM.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_IGatewayEVM *IGatewayEVMTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _IGatewayEVM.Contract.ExecuteWithERC20(&_IGatewayEVM.TransactOpts, token, to, amount, data) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_IGatewayEVM *IGatewayEVMTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.contract.Transact(opts, "send", recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_IGatewayEVM *IGatewayEVMSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.Contract.Send(&_IGatewayEVM.TransactOpts, recipient, amount) +} + +// Send is a paid mutator transaction binding the contract method 0x9372c4ab. +// +// Solidity: function send(bytes recipient, uint256 amount) payable returns() +func (_IGatewayEVM *IGatewayEVMTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.Contract.Send(&_IGatewayEVM.TransactOpts, recipient, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() +func (_IGatewayEVM *IGatewayEVMTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.contract.Transact(opts, "sendERC20", recipient, asset, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() +func (_IGatewayEVM *IGatewayEVMSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.Contract.SendERC20(&_IGatewayEVM.TransactOpts, recipient, asset, amount) +} + +// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// +// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() +func (_IGatewayEVM *IGatewayEVMTransactorSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { + return _IGatewayEVM.Contract.SendERC20(&_IGatewayEVM.TransactOpts, recipient, asset, amount) +} diff --git a/pkg/contracts/prototypes/receiver.sol/receiver.go b/pkg/contracts/prototypes/evm/receiver.sol/receiver.go similarity index 99% rename from pkg/contracts/prototypes/receiver.sol/receiver.go rename to pkg/contracts/prototypes/evm/receiver.sol/receiver.go index 8e04e47c..102c632e 100644 --- a/pkg/contracts/prototypes/receiver.sol/receiver.go +++ b/pkg/contracts/prototypes/evm/receiver.sol/receiver.go @@ -32,7 +32,7 @@ var ( // ReceiverMetaData contains all meta data concerning the Receiver contract. var ReceiverMetaData = &bind.MetaData{ ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedD\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveC\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveD\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ReceiverABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/testerc20.sol/testerc20.go b/pkg/contracts/prototypes/evm/testerc20.sol/testerc20.go similarity index 99% rename from pkg/contracts/prototypes/testerc20.sol/testerc20.go rename to pkg/contracts/prototypes/evm/testerc20.sol/testerc20.go index 24a6d264..5e2a85eb 100644 --- a/pkg/contracts/prototypes/testerc20.sol/testerc20.go +++ b/pkg/contracts/prototypes/evm/testerc20.sol/testerc20.go @@ -32,7 +32,7 @@ var ( // TestERC20MetaData contains all meta data concerning the TestERC20 contract. var TestERC20MetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // TestERC20ABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/gateway.sol/gateway.go b/pkg/contracts/prototypes/gateway.sol/gateway.go deleted file mode 100644 index e0cb7151..00000000 --- a/pkg/contracts/prototypes/gateway.sol/gateway.go +++ /dev/null @@ -1,1475 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package gateway - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// GatewayMetaData contains all meta data concerning the Gateway contract. -var GatewayMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", -} - -// GatewayABI is the input ABI used to generate the binding from. -// Deprecated: Use GatewayMetaData.ABI instead. -var GatewayABI = GatewayMetaData.ABI - -// GatewayBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayMetaData.Bin instead. -var GatewayBin = GatewayMetaData.Bin - -// DeployGateway deploys a new Ethereum contract, binding an instance of Gateway to it. -func DeployGateway(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Gateway, error) { - parsed, err := GatewayMetaData.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(GatewayBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &Gateway{GatewayCaller: GatewayCaller{contract: contract}, GatewayTransactor: GatewayTransactor{contract: contract}, GatewayFilterer: GatewayFilterer{contract: contract}}, nil -} - -// Gateway is an auto generated Go binding around an Ethereum contract. -type Gateway struct { - GatewayCaller // Read-only binding to the contract - GatewayTransactor // Write-only binding to the contract - GatewayFilterer // Log filterer for contract events -} - -// GatewayCaller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayTransactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewaySession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type GatewaySession struct { - Contract *Gateway // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type GatewayCallerSession struct { - Contract *GatewayCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// GatewayTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type GatewayTransactorSession struct { - Contract *GatewayTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayRaw is an auto generated low-level Go binding around an Ethereum contract. -type GatewayRaw struct { - Contract *Gateway // Generic contract binding to access the raw methods on -} - -// GatewayCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type GatewayCallerRaw struct { - Contract *GatewayCaller // Generic read-only contract binding to access the raw methods on -} - -// GatewayTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type GatewayTransactorRaw struct { - Contract *GatewayTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewGateway creates a new instance of Gateway, bound to a specific deployed contract. -func NewGateway(address common.Address, backend bind.ContractBackend) (*Gateway, error) { - contract, err := bindGateway(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &Gateway{GatewayCaller: GatewayCaller{contract: contract}, GatewayTransactor: GatewayTransactor{contract: contract}, GatewayFilterer: GatewayFilterer{contract: contract}}, nil -} - -// NewGatewayCaller creates a new read-only instance of Gateway, bound to a specific deployed contract. -func NewGatewayCaller(address common.Address, caller bind.ContractCaller) (*GatewayCaller, error) { - contract, err := bindGateway(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &GatewayCaller{contract: contract}, nil -} - -// NewGatewayTransactor creates a new write-only instance of Gateway, bound to a specific deployed contract. -func NewGatewayTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayTransactor, error) { - contract, err := bindGateway(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &GatewayTransactor{contract: contract}, nil -} - -// NewGatewayFilterer creates a new log filterer instance of Gateway, bound to a specific deployed contract. -func NewGatewayFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayFilterer, error) { - contract, err := bindGateway(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &GatewayFilterer{contract: contract}, nil -} - -// bindGateway binds a generic wrapper to an already deployed contract. -func bindGateway(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := GatewayMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Gateway *GatewayRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Gateway.Contract.GatewayCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Gateway *GatewayRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Gateway.Contract.GatewayTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Gateway *GatewayRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Gateway.Contract.GatewayTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Gateway *GatewayCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Gateway.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Gateway *GatewayTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Gateway.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Gateway *GatewayTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Gateway.Contract.contract.Transact(opts, method, params...) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_Gateway *GatewayCaller) Custody(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _Gateway.contract.Call(opts, &out, "custody") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_Gateway *GatewaySession) Custody() (common.Address, error) { - return _Gateway.Contract.Custody(&_Gateway.CallOpts) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_Gateway *GatewayCallerSession) Custody() (common.Address, error) { - return _Gateway.Contract.Custody(&_Gateway.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_Gateway *GatewayCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _Gateway.contract.Call(opts, &out, "owner") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_Gateway *GatewaySession) Owner() (common.Address, error) { - return _Gateway.Contract.Owner(&_Gateway.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_Gateway *GatewayCallerSession) Owner() (common.Address, error) { - return _Gateway.Contract.Owner(&_Gateway.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_Gateway *GatewayCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _Gateway.contract.Call(opts, &out, "proxiableUUID") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_Gateway *GatewaySession) ProxiableUUID() ([32]byte, error) { - return _Gateway.Contract.ProxiableUUID(&_Gateway.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_Gateway *GatewayCallerSession) ProxiableUUID() ([32]byte, error) { - return _Gateway.Contract.ProxiableUUID(&_Gateway.CallOpts) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewayTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "execute", destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewaySession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.Execute(&_Gateway.TransactOpts, destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_Gateway *GatewayTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.Execute(&_Gateway.TransactOpts, destination, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_Gateway *GatewayTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "executeWithERC20", token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_Gateway *GatewaySession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.ExecuteWithERC20(&_Gateway.TransactOpts, token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_Gateway *GatewayTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.ExecuteWithERC20(&_Gateway.TransactOpts, token, to, amount, data) -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_Gateway *GatewayTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "initialize") -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_Gateway *GatewaySession) Initialize() (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_Gateway *GatewayTransactorSession) Initialize() (*types.Transaction, error) { - return _Gateway.Contract.Initialize(&_Gateway.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_Gateway *GatewayTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_Gateway *GatewaySession) RenounceOwnership() (*types.Transaction, error) { - return _Gateway.Contract.RenounceOwnership(&_Gateway.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_Gateway *GatewayTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _Gateway.Contract.RenounceOwnership(&_Gateway.TransactOpts) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_Gateway *GatewayTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "setCustody", _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_Gateway *GatewaySession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _Gateway.Contract.SetCustody(&_Gateway.TransactOpts, _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_Gateway *GatewayTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _Gateway.Contract.SetCustody(&_Gateway.TransactOpts, _custody) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_Gateway *GatewayTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_Gateway *GatewaySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _Gateway.Contract.TransferOwnership(&_Gateway.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_Gateway *GatewayTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _Gateway.Contract.TransferOwnership(&_Gateway.TransactOpts, newOwner) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_Gateway *GatewayTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "upgradeTo", newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_Gateway *GatewaySession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _Gateway.Contract.UpgradeTo(&_Gateway.TransactOpts, newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_Gateway *GatewayTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _Gateway.Contract.UpgradeTo(&_Gateway.TransactOpts, newImplementation) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_Gateway *GatewayTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_Gateway *GatewaySession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.UpgradeToAndCall(&_Gateway.TransactOpts, newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_Gateway *GatewayTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _Gateway.Contract.UpgradeToAndCall(&_Gateway.TransactOpts, newImplementation, data) -} - -// GatewayAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the Gateway contract. -type GatewayAdminChangedIterator struct { - Event *GatewayAdminChanged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayAdminChangedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayAdminChangedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayAdminChangedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayAdminChanged represents a AdminChanged event raised by the Gateway contract. -type GatewayAdminChanged struct { - PreviousAdmin common.Address - NewAdmin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_Gateway *GatewayFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayAdminChangedIterator, error) { - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return &GatewayAdminChangedIterator{contract: _Gateway.contract, event: "AdminChanged", logs: logs, sub: sub}, nil -} - -// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_Gateway *GatewayFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayAdminChanged) (event.Subscription, error) { - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayAdminChanged) - if err := _Gateway.contract.UnpackLog(event, "AdminChanged", 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 -} - -// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_Gateway *GatewayFilterer) ParseAdminChanged(log types.Log) (*GatewayAdminChanged, error) { - event := new(GatewayAdminChanged) - if err := _Gateway.contract.UnpackLog(event, "AdminChanged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the Gateway contract. -type GatewayBeaconUpgradedIterator struct { - Event *GatewayBeaconUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayBeaconUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayBeaconUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayBeaconUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayBeaconUpgraded represents a BeaconUpgraded event raised by the Gateway contract. -type GatewayBeaconUpgraded struct { - Beacon common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_Gateway *GatewayFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayBeaconUpgradedIterator, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return &GatewayBeaconUpgradedIterator{contract: _Gateway.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil -} - -// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_Gateway *GatewayFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayBeaconUpgraded) - if err := _Gateway.contract.UnpackLog(event, "BeaconUpgraded", 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 -} - -// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_Gateway *GatewayFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayBeaconUpgraded, error) { - event := new(GatewayBeaconUpgraded) - if err := _Gateway.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the Gateway contract. -type GatewayExecutedIterator struct { - Event *GatewayExecuted // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayExecutedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayExecuted) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayExecuted) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayExecutedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayExecutedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayExecuted represents a Executed event raised by the Gateway contract. -type GatewayExecuted struct { - Destination common.Address - Value *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayExecutedIterator, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Executed", destinationRule) - if err != nil { - return nil, err - } - return &GatewayExecutedIterator{contract: _Gateway.contract, event: "Executed", logs: logs, sub: sub}, nil -} - -// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayExecuted, destination []common.Address) (event.Subscription, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "Executed", destinationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayExecuted) - if err := _Gateway.contract.UnpackLog(event, "Executed", 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 -} - -// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_Gateway *GatewayFilterer) ParseExecuted(log types.Log) (*GatewayExecuted, error) { - event := new(GatewayExecuted) - if err := _Gateway.contract.UnpackLog(event, "Executed", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the Gateway contract. -type GatewayExecutedWithERC20Iterator struct { - Event *GatewayExecutedWithERC20 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayExecutedWithERC20Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayExecutedWithERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayExecutedWithERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayExecutedWithERC20Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayExecutedWithERC20Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayExecutedWithERC20 represents a ExecutedWithERC20 event raised by the Gateway contract. -type GatewayExecutedWithERC20 struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayExecutedWithERC20Iterator, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) - if err != nil { - return nil, err - } - return &GatewayExecutedWithERC20Iterator{contract: _Gateway.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil -} - -// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayExecutedWithERC20) - if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", 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 -} - -// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_Gateway *GatewayFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayExecutedWithERC20, error) { - event := new(GatewayExecutedWithERC20) - if err := _Gateway.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the Gateway contract. -type GatewayInitializedIterator struct { - Event *GatewayInitialized // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayInitializedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayInitialized represents a Initialized event raised by the Gateway contract. -type GatewayInitialized struct { - Version uint8 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_Gateway *GatewayFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayInitializedIterator, error) { - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &GatewayInitializedIterator{contract: _Gateway.contract, event: "Initialized", logs: logs, sub: sub}, nil -} - -// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_Gateway *GatewayFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayInitialized) (event.Subscription, error) { - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayInitialized) - if err := _Gateway.contract.UnpackLog(event, "Initialized", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_Gateway *GatewayFilterer) ParseInitialized(log types.Log) (*GatewayInitialized, error) { - event := new(GatewayInitialized) - if err := _Gateway.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Gateway contract. -type GatewayOwnershipTransferredIterator struct { - Event *GatewayOwnershipTransferred // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayOwnershipTransferredIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayOwnershipTransferred represents a OwnershipTransferred event raised by the Gateway contract. -type GatewayOwnershipTransferred struct { - PreviousOwner common.Address - NewOwner common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_Gateway *GatewayFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayOwnershipTransferredIterator, 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 := _Gateway.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &GatewayOwnershipTransferredIterator{contract: _Gateway.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil -} - -// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_Gateway *GatewayFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayOwnershipTransferred, 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 := _Gateway.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayOwnershipTransferred) - if err := _Gateway.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_Gateway *GatewayFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayOwnershipTransferred, error) { - event := new(GatewayOwnershipTransferred) - if err := _Gateway.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the Gateway contract. -type GatewayUpgradedIterator struct { - Event *GatewayUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgraded represents a Upgraded event raised by the Gateway contract. -type GatewayUpgraded struct { - Implementation common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_Gateway *GatewayFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayUpgradedIterator, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _Gateway.contract.FilterLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return &GatewayUpgradedIterator{contract: _Gateway.contract, event: "Upgraded", logs: logs, sub: sub}, nil -} - -// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_Gateway *GatewayFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgraded, implementation []common.Address) (event.Subscription, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _Gateway.contract.WatchLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgraded) - if err := _Gateway.contract.UnpackLog(event, "Upgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_Gateway *GatewayFilterer) ParseUpgraded(log types.Log) (*GatewayUpgraded, error) { - event := new(GatewayUpgraded) - if err := _Gateway.contract.UnpackLog(event, "Upgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go b/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go deleted file mode 100644 index 8a542d44..00000000 --- a/pkg/contracts/prototypes/gatewayupgradetest.sol/gatewayupgradetest.go +++ /dev/null @@ -1,1475 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package gatewayupgradetest - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// GatewayUpgradeTestMetaData contains all meta data concerning the GatewayUpgradeTest contract. -var GatewayUpgradeTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20V2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", -} - -// GatewayUpgradeTestABI is the input ABI used to generate the binding from. -// Deprecated: Use GatewayUpgradeTestMetaData.ABI instead. -var GatewayUpgradeTestABI = GatewayUpgradeTestMetaData.ABI - -// GatewayUpgradeTestBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayUpgradeTestMetaData.Bin instead. -var GatewayUpgradeTestBin = GatewayUpgradeTestMetaData.Bin - -// DeployGatewayUpgradeTest deploys a new Ethereum contract, binding an instance of GatewayUpgradeTest to it. -func DeployGatewayUpgradeTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayUpgradeTest, error) { - parsed, err := GatewayUpgradeTestMetaData.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(GatewayUpgradeTestBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil -} - -// GatewayUpgradeTest is an auto generated Go binding around an Ethereum contract. -type GatewayUpgradeTest struct { - GatewayUpgradeTestCaller // Read-only binding to the contract - GatewayUpgradeTestTransactor // Write-only binding to the contract - GatewayUpgradeTestFilterer // Log filterer for contract events -} - -// GatewayUpgradeTestCaller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayUpgradeTestCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayUpgradeTestTransactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayUpgradeTestTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayUpgradeTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayUpgradeTestFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayUpgradeTestSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type GatewayUpgradeTestSession struct { - Contract *GatewayUpgradeTest // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayUpgradeTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type GatewayUpgradeTestCallerSession struct { - Contract *GatewayUpgradeTestCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// GatewayUpgradeTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type GatewayUpgradeTestTransactorSession struct { - Contract *GatewayUpgradeTestTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayUpgradeTestRaw is an auto generated low-level Go binding around an Ethereum contract. -type GatewayUpgradeTestRaw struct { - Contract *GatewayUpgradeTest // Generic contract binding to access the raw methods on -} - -// GatewayUpgradeTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type GatewayUpgradeTestCallerRaw struct { - Contract *GatewayUpgradeTestCaller // Generic read-only contract binding to access the raw methods on -} - -// GatewayUpgradeTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type GatewayUpgradeTestTransactorRaw struct { - Contract *GatewayUpgradeTestTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewGatewayUpgradeTest creates a new instance of GatewayUpgradeTest, bound to a specific deployed contract. -func NewGatewayUpgradeTest(address common.Address, backend bind.ContractBackend) (*GatewayUpgradeTest, error) { - contract, err := bindGatewayUpgradeTest(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &GatewayUpgradeTest{GatewayUpgradeTestCaller: GatewayUpgradeTestCaller{contract: contract}, GatewayUpgradeTestTransactor: GatewayUpgradeTestTransactor{contract: contract}, GatewayUpgradeTestFilterer: GatewayUpgradeTestFilterer{contract: contract}}, nil -} - -// NewGatewayUpgradeTestCaller creates a new read-only instance of GatewayUpgradeTest, bound to a specific deployed contract. -func NewGatewayUpgradeTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayUpgradeTestCaller, error) { - contract, err := bindGatewayUpgradeTest(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestCaller{contract: contract}, nil -} - -// NewGatewayUpgradeTestTransactor creates a new write-only instance of GatewayUpgradeTest, bound to a specific deployed contract. -func NewGatewayUpgradeTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayUpgradeTestTransactor, error) { - contract, err := bindGatewayUpgradeTest(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestTransactor{contract: contract}, nil -} - -// NewGatewayUpgradeTestFilterer creates a new log filterer instance of GatewayUpgradeTest, bound to a specific deployed contract. -func NewGatewayUpgradeTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayUpgradeTestFilterer, error) { - contract, err := bindGatewayUpgradeTest(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestFilterer{contract: contract}, nil -} - -// bindGatewayUpgradeTest binds a generic wrapper to an already deployed contract. -func bindGatewayUpgradeTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := GatewayUpgradeTestMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_GatewayUpgradeTest *GatewayUpgradeTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.GatewayUpgradeTestTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_GatewayUpgradeTest *GatewayUpgradeTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayUpgradeTest.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.contract.Transact(opts, method, params...) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "custody") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Custody() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Custody(&_GatewayUpgradeTest.CallOpts) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Custody() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Custody(&_GatewayUpgradeTest.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "owner") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Owner() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Owner(&_GatewayUpgradeTest.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) Owner() (common.Address, error) { - return _GatewayUpgradeTest.Contract.Owner(&_GatewayUpgradeTest.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayUpgradeTest *GatewayUpgradeTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _GatewayUpgradeTest.contract.Call(opts, &out, "proxiableUUID") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) ProxiableUUID() ([32]byte, error) { - return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayUpgradeTest *GatewayUpgradeTestCallerSession) ProxiableUUID() ([32]byte, error) { - return _GatewayUpgradeTest.Contract.ProxiableUUID(&_GatewayUpgradeTest.CallOpts) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "execute", destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Execute(&_GatewayUpgradeTest.TransactOpts, destination, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "executeWithERC20", token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.ExecuteWithERC20(&_GatewayUpgradeTest.TransactOpts, token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.ExecuteWithERC20(&_GatewayUpgradeTest.TransactOpts, token, to, amount, data) -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "initialize") -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) Initialize() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) -} - -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. -// -// Solidity: function initialize() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) Initialize() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.Initialize(&_GatewayUpgradeTest.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.RenounceOwnership(&_GatewayUpgradeTest.TransactOpts) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "setCustody", _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.SetCustody(&_GatewayUpgradeTest.TransactOpts, _custody) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.TransferOwnership(&_GatewayUpgradeTest.TransactOpts, newOwner) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "upgradeTo", newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeTo(&_GatewayUpgradeTest.TransactOpts, newImplementation) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayUpgradeTest *GatewayUpgradeTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayUpgradeTest.Contract.UpgradeToAndCall(&_GatewayUpgradeTest.TransactOpts, newImplementation, data) -} - -// GatewayUpgradeTestAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestAdminChangedIterator struct { - Event *GatewayUpgradeTestAdminChanged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestAdminChangedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestAdminChangedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestAdminChangedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestAdminChanged represents a AdminChanged event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestAdminChanged struct { - PreviousAdmin common.Address - NewAdmin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayUpgradeTestAdminChangedIterator, error) { - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return &GatewayUpgradeTestAdminChangedIterator{contract: _GatewayUpgradeTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil -} - -// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestAdminChanged) (event.Subscription, error) { - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestAdminChanged) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "AdminChanged", 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 -} - -// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseAdminChanged(log types.Log) (*GatewayUpgradeTestAdminChanged, error) { - event := new(GatewayUpgradeTestAdminChanged) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestBeaconUpgradedIterator struct { - Event *GatewayUpgradeTestBeaconUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestBeaconUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestBeaconUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestBeaconUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestBeaconUpgraded struct { - Beacon common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayUpgradeTestBeaconUpgradedIterator, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestBeaconUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil -} - -// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestBeaconUpgraded) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", 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 -} - -// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayUpgradeTestBeaconUpgraded, error) { - event := new(GatewayUpgradeTestBeaconUpgraded) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedV2Iterator struct { - Event *GatewayUpgradeTestExecutedV2 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestExecutedV2Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedV2) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedV2) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestExecutedV2Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestExecutedV2Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedV2 struct { - Destination common.Address - Value *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. -// -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayUpgradeTestExecutedV2Iterator, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestExecutedV2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil -} - -// WatchExecutedV2 is a free log subscription operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. -// -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestExecutedV2) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedV2", 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 -} - -// ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. -// -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedV2(log types.Log) (*GatewayUpgradeTestExecutedV2, error) { - event := new(GatewayUpgradeTestExecutedV2) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestExecutedWithERC20V2Iterator is returned from FilterExecutedWithERC20V2 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20V2 events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedWithERC20V2Iterator struct { - Event *GatewayUpgradeTestExecutedWithERC20V2 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestExecutedWithERC20V2) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestExecutedWithERC20V2Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestExecutedWithERC20V2 represents a ExecutedWithERC20V2 event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestExecutedWithERC20V2 struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecutedWithERC20V2 is a free log retrieval operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. -// -// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterExecutedWithERC20V2(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayUpgradeTestExecutedWithERC20V2Iterator, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestExecutedWithERC20V2Iterator{contract: _GatewayUpgradeTest.contract, event: "ExecutedWithERC20V2", logs: logs, sub: sub}, nil -} - -// WatchExecutedWithERC20V2 is a free log subscription operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. -// -// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchExecutedWithERC20V2(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestExecutedWithERC20V2, token []common.Address, to []common.Address) (event.Subscription, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20V2", tokenRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestExecutedWithERC20V2) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20V2", 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 -} - -// ParseExecutedWithERC20V2 is a log parse operation binding the contract event 0x887e0acc3616142401641abfc50d7d7ae169b6ce55d8dc06ff5e21501ddb341b. -// -// Solidity: event ExecutedWithERC20V2(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseExecutedWithERC20V2(log types.Log) (*GatewayUpgradeTestExecutedWithERC20V2, error) { - event := new(GatewayUpgradeTestExecutedWithERC20V2) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20V2", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestInitializedIterator struct { - Event *GatewayUpgradeTestInitialized // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestInitializedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestInitialized represents a Initialized event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestInitialized struct { - Version uint8 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayUpgradeTestInitializedIterator, error) { - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &GatewayUpgradeTestInitializedIterator{contract: _GatewayUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil -} - -// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestInitialized) (event.Subscription, error) { - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestInitialized) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseInitialized(log types.Log) (*GatewayUpgradeTestInitialized, error) { - event := new(GatewayUpgradeTestInitialized) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestOwnershipTransferredIterator struct { - Event *GatewayUpgradeTestOwnershipTransferred // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestOwnershipTransferredIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestOwnershipTransferred struct { - PreviousOwner common.Address - NewOwner common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayUpgradeTestOwnershipTransferredIterator, 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 := _GatewayUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestOwnershipTransferredIterator{contract: _GatewayUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil -} - -// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestOwnershipTransferred, 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 := _GatewayUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestOwnershipTransferred) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayUpgradeTestOwnershipTransferred, error) { - event := new(GatewayUpgradeTestOwnershipTransferred) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayUpgradeTestUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestUpgradedIterator struct { - Event *GatewayUpgradeTestUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayUpgradeTestUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayUpgradeTestUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayUpgradeTestUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayUpgradeTestUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayUpgradeTestUpgraded represents a Upgraded event raised by the GatewayUpgradeTest contract. -type GatewayUpgradeTestUpgraded struct { - Implementation common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayUpgradeTestUpgradedIterator, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.FilterLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return &GatewayUpgradeTestUpgradedIterator{contract: _GatewayUpgradeTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil -} - -// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayUpgradeTestUpgraded, implementation []common.Address) (event.Subscription, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _GatewayUpgradeTest.contract.WatchLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayUpgradeTestUpgraded) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayUpgradeTest *GatewayUpgradeTestFilterer) ParseUpgraded(log types.Log) (*GatewayUpgradeTestUpgraded, error) { - event := new(GatewayUpgradeTestUpgraded) - if err := _GatewayUpgradeTest.contract.UnpackLog(event, "Upgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/prototypes/interfaces.sol/igateway.go b/pkg/contracts/prototypes/interfaces.sol/igateway.go deleted file mode 100644 index 34981e17..00000000 --- a/pkg/contracts/prototypes/interfaces.sol/igateway.go +++ /dev/null @@ -1,223 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package interfaces - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// IGatewayMetaData contains all meta data concerning the IGateway contract. -var IGatewayMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", -} - -// IGatewayABI is the input ABI used to generate the binding from. -// Deprecated: Use IGatewayMetaData.ABI instead. -var IGatewayABI = IGatewayMetaData.ABI - -// IGateway is an auto generated Go binding around an Ethereum contract. -type IGateway struct { - IGatewayCaller // Read-only binding to the contract - IGatewayTransactor // Write-only binding to the contract - IGatewayFilterer // Log filterer for contract events -} - -// IGatewayCaller is an auto generated read-only Go binding around an Ethereum contract. -type IGatewayCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IGatewayTransactor is an auto generated write-only Go binding around an Ethereum contract. -type IGatewayTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IGatewayFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type IGatewayFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IGatewaySession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type IGatewaySession struct { - Contract *IGateway // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IGatewayCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type IGatewayCallerSession struct { - Contract *IGatewayCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// IGatewayTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type IGatewayTransactorSession struct { - Contract *IGatewayTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IGatewayRaw is an auto generated low-level Go binding around an Ethereum contract. -type IGatewayRaw struct { - Contract *IGateway // Generic contract binding to access the raw methods on -} - -// IGatewayCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type IGatewayCallerRaw struct { - Contract *IGatewayCaller // Generic read-only contract binding to access the raw methods on -} - -// IGatewayTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type IGatewayTransactorRaw struct { - Contract *IGatewayTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewIGateway creates a new instance of IGateway, bound to a specific deployed contract. -func NewIGateway(address common.Address, backend bind.ContractBackend) (*IGateway, error) { - contract, err := bindIGateway(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &IGateway{IGatewayCaller: IGatewayCaller{contract: contract}, IGatewayTransactor: IGatewayTransactor{contract: contract}, IGatewayFilterer: IGatewayFilterer{contract: contract}}, nil -} - -// NewIGatewayCaller creates a new read-only instance of IGateway, bound to a specific deployed contract. -func NewIGatewayCaller(address common.Address, caller bind.ContractCaller) (*IGatewayCaller, error) { - contract, err := bindIGateway(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &IGatewayCaller{contract: contract}, nil -} - -// NewIGatewayTransactor creates a new write-only instance of IGateway, bound to a specific deployed contract. -func NewIGatewayTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayTransactor, error) { - contract, err := bindIGateway(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &IGatewayTransactor{contract: contract}, nil -} - -// NewIGatewayFilterer creates a new log filterer instance of IGateway, bound to a specific deployed contract. -func NewIGatewayFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayFilterer, error) { - contract, err := bindIGateway(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &IGatewayFilterer{contract: contract}, nil -} - -// bindIGateway binds a generic wrapper to an already deployed contract. -func bindIGateway(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := IGatewayMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IGateway *IGatewayRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IGateway.Contract.IGatewayCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IGateway *IGatewayRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IGateway.Contract.IGatewayTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IGateway *IGatewayRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IGateway.Contract.IGatewayTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IGateway *IGatewayCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IGateway.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IGateway *IGatewayTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IGateway.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IGateway *IGatewayTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IGateway.Contract.contract.Transact(opts, method, params...) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_IGateway *IGatewayTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _IGateway.contract.Transact(opts, "execute", destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_IGateway *IGatewaySession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _IGateway.Contract.Execute(&_IGateway.TransactOpts, destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_IGateway *IGatewayTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _IGateway.Contract.Execute(&_IGateway.TransactOpts, destination, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_IGateway *IGatewayTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _IGateway.contract.Transact(opts, "executeWithERC20", token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_IGateway *IGatewaySession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _IGateway.Contract.ExecuteWithERC20(&_IGateway.TransactOpts, token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_IGateway *IGatewayTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _IGateway.Contract.ExecuteWithERC20(&_IGateway.TransactOpts, token, to, amount, data) -} diff --git a/test/prototypes/GatewayEVM.spec.ts b/test/prototypes/GatewayEVM.spec.ts new file mode 100644 index 00000000..1937900b --- /dev/null +++ b/test/prototypes/GatewayEVM.spec.ts @@ -0,0 +1,311 @@ +import { expect } from "chai"; +import { BigNumber, Contract } from "ethers"; +import { ethers, upgrades } from "hardhat"; + +describe("GatewayEVM inbound", function () { + let receiver: Contract; + let gateway: Contract; + let token: Contract; + let custody: Contract; + let owner: any, destination: any, tssAddress: any; + + beforeEach(async function () { + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const Receiver = await ethers.getContractFactory("Receiver"); + const Gateway = await ethers.getContractFactory("GatewayEVM"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + [owner, destination, tssAddress] = await ethers.getSigners(); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + receiver = await Receiver.deploy(); + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { + initializer: "initialize", + kind: "uups", + }); + custody = await Custody.deploy(gateway.address); + + gateway.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(owner.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + }); + + it("should forward call to Receiver's receiveA function", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data + const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); + + // Call execute on the Gateway contract + const tx = await gateway.execute(receiver.address, data, { value: value }); + + // Listen for the event + await expect(tx).to.emit(gateway, "Executed").withArgs(receiver.address, value, data); + await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); + }); + + it("should forward call to Receiver's receiveB function", async function () { + const strs = ["Hello", "Hardhat"]; + const nums = [1, 2, 3]; + const flag = false; + const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); + const tx = await gateway.execute(receiver.address, data); + await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); + }); + + it("should forward call with withdrawAndCall and give allowance to destination contract", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveC + const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); + + // Withdraw and call + const tx = await custody.withdrawAndCall(token.address, receiver.address, amount, data); + + // Verify the event was emitted + await expect(tx) + .to.emit(receiver, "ReceivedC") + .withArgs(gateway.address, amount, token.address, destination.address); + + // Verify that the tokens were transferred to the destination address + const receiverBalance = await token.balanceOf(destination.address); + expect(receiverBalance).to.equal(amount); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("400")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); + + it("should forward call to Receiver's receiveD function", async function () { + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Execute the call + const tx = await gateway.execute(receiver.address, data); + + // Verify the event was emitted + await expect(tx).to.emit(receiver, "ReceivedD").withArgs(gateway.address); + }); + + it("should forward call to Receiver's receiveD function through withdrawAndCall and return ERC20 tokens to custody", async function () { + const amount = ethers.utils.parseEther("100"); + + // Encode the function call data for receiveD + const data = receiver.interface.encodeFunctionData("receiveD"); + + // Withdraw and call + await custody.withdrawAndCall(token.address, receiver.address, amount, data); + + // Verify the event was emitted + await expect(custody.withdrawAndCall(token.address, receiver.address, amount, data)) + .to.emit(receiver, "ReceivedD") + .withArgs(gateway.address); + + // Verify that the remaining tokens were refunded to the Custody contract + const remainingBalance = await token.balanceOf(custody.address); + expect(remainingBalance).to.equal(ethers.utils.parseEther("500")); + + // Verify that the approval was reset + const allowance = await token.allowance(gateway.address, receiver.address); + expect(allowance).to.equal(0); + }); +}); + +describe("GatewayEVM inbound", function () { + let gateway: Contract; + let token: Contract; + let custody: Contract; + let owner: any, destination: any, tssAddress: any; + + beforeEach(async function () { + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const Gateway = await ethers.getContractFactory("GatewayEVM"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + [owner, destination, tssAddress] = await ethers.getSigners(); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { + initializer: "initialize", + kind: "uups", + }); + custody = await Custody.deploy(gateway.address); + + gateway.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(owner.address, ethers.utils.parseEther("1000")); + }); + + it("should deposit erc20 to custody and emit event", async function () { + const amount = ethers.utils.parseEther("100"); + + const custodyBalanceBefore = await token.balanceOf(custody.address); + expect(custodyBalanceBefore).to.equal(0); + + await token.approve(gateway.address, amount); + + const tx = await gateway["deposit(address,uint256,address)"](destination.address, amount, token.address); + + const custodyBalanceAfter = await token.balanceOf(custody.address); + expect(custodyBalanceAfter).to.equal(amount); + + const ownerBalanceAfter = await token.balanceOf(owner.address); + expect(ownerBalanceAfter).to.equal(ethers.utils.parseEther("900")); + + await expect(tx) + .to.emit(gateway, "Deposit") + .withArgs( + ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(destination.address), + amount, + ethers.utils.getAddress(token.address), + "0x" + ); + }); + + it("should fail to deposit erc20 to custody and emit event if amount is 0", async function () { + const amount = ethers.utils.parseEther("0"); + await token.approve(gateway.address, amount); + + await expect( + gateway["deposit(address,uint256,address)"](destination.address, amount, token.address) + ).to.be.revertedWith("InsufficientERC20Amount"); + }); + + it("should deposit eth to tss and emit event", async function () { + const amount = ethers.utils.parseEther("100"); + + const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; + + const tx = await gateway["deposit(address)"](destination.address, { value: amount }); + + const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); + + await expect(tx) + .to.emit(gateway, "Deposit") + .withArgs( + ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(destination.address), + amount, + ethers.constants.AddressZero, + "0x" + ); + }); + + it("should fail to deposit eth to tss and emit event if amount is 0", async function () { + const amount = ethers.utils.parseEther("0"); + + await expect(gateway["deposit(address)"](destination.address, { value: amount })).to.be.revertedWith( + "InsufficientETHAmount" + ); + }); + + it("should deposit erc20 to custody and emit event with payload", async function () { + const amount = ethers.utils.parseEther("100"); + + const custodyBalanceBefore = await token.balanceOf(custody.address); + expect(custodyBalanceBefore).to.equal(0); + + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + await token.approve(gateway.address, amount); + + const tx = await gateway["depositAndCall(address,uint256,address,bytes)"]( + destination.address, + amount, + token.address, + payload + ); + + const custodyBalanceAfter = await token.balanceOf(custody.address); + expect(custodyBalanceAfter).to.equal(amount); + + const ownerBalanceAfter = await token.balanceOf(owner.address); + expect(ownerBalanceAfter).to.equal(ethers.utils.parseEther("900")); + + await expect(tx) + .to.emit(gateway, "Deposit") + .withArgs( + ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(destination.address), + amount, + ethers.utils.getAddress(token.address), + payload + ); + }); + + it("should fail to deposit erc20 to custody and emit event with payload if amount is 0", async function () { + const amount = ethers.utils.parseEther("0"); + + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + await expect( + gateway["depositAndCall(address,uint256,address,bytes)"](destination.address, amount, token.address, payload) + ).to.be.revertedWith("InsufficientERC20Amount"); + }); + + it("should deposit eth to tss and emit event with payload", async function () { + const amount = ethers.utils.parseEther("100"); + + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tssAddressBalanceBefore = (await ethers.provider.getBalance(tssAddress.address)) as BigNumber; + + const tx = await gateway["depositAndCall(address,bytes)"](destination.address, payload, { value: amount }); + + const tssAddressBalanceAfter = await ethers.provider.getBalance(tssAddress.address); + expect(tssAddressBalanceAfter).to.equal(tssAddressBalanceBefore.add(amount)); + + await expect(tx) + .to.emit(gateway, "Deposit") + .withArgs( + ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(destination.address), + amount, + ethers.constants.AddressZero, + payload + ); + }); + + it("should fail to deposit eth to tss and emit event with payload if amount is 0", async function () { + const amount = ethers.utils.parseEther("0"); + + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + await expect( + gateway["depositAndCall(address,bytes)"](destination.address, payload, { value: amount }) + ).to.be.revertedWith("InsufficientETHAmount"); + }); + + it("should call and emit with payload and without asset transfer", async function () { + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const payload = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tx = await gateway.call(destination.address, payload); + + await expect(tx) + .to.emit(gateway, "Call") + .withArgs(ethers.utils.getAddress(owner.address), ethers.utils.getAddress(destination.address), payload); + }); +}); diff --git a/test/prototypes/GatewayUniswap.spec.ts b/test/prototypes/GatewayEVMUniswap.spec.ts similarity index 89% rename from test/prototypes/GatewayUniswap.spec.ts rename to test/prototypes/GatewayEVMUniswap.spec.ts index 7ee89a0c..c4e392fa 100644 --- a/test/prototypes/GatewayUniswap.spec.ts +++ b/test/prototypes/GatewayEVMUniswap.spec.ts @@ -6,7 +6,7 @@ import { UniswapV2Deployer } from "uniswap-v2-deploy-plugin"; import { ERC20, ERC20CustodyNew, - Gateway, + GatewayEVM, Receiver, TestERC20, UniswapV2Factory, @@ -14,18 +14,19 @@ import { UniswapV2Router02, } from "../../typechain-types"; -describe("Uniswap Integration with Gateway", function () { +describe("Uniswap Integration with GatewayEVM", function () { let tokenA: TestERC20; let tokenB: TestERC20; let factory: UniswapV2Factory; let router: UniswapV2Router02; let pair: UniswapV2Pair; let custody: ERC20CustodyNew; - let gateway: Gateway; + let gateway: GatewayEVM; let owner, addr1, addr2; + let tssAddress; beforeEach(async function () { - [owner, addr1, addr2] = await ethers.getSigners(); + [owner, addr1, addr2, tssAddress] = await ethers.getSigners(); // Deploy TestERC20 tokens const TestERC20 = await ethers.getContractFactory("TestERC20"); @@ -56,12 +57,12 @@ describe("Uniswap Integration with Gateway", function () { ); // Deploy Gateway and Custody Contracts - const Gateway = await ethers.getContractFactory("Gateway"); + const Gateway = await ethers.getContractFactory("GatewayEVM"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - gateway = (await upgrades.deployProxy(Gateway, [], { + gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address], { initializer: "initialize", kind: "uups", - })) as Gateway; + })) as GatewayEVM; custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; // Transfer some tokens to the custody contract diff --git a/test/prototypes/GatewayUpgrade.spec.ts b/test/prototypes/GatewayEVMUpgrade.spec.ts similarity index 75% rename from test/prototypes/GatewayUpgrade.spec.ts rename to test/prototypes/GatewayEVMUpgrade.spec.ts index 5e25924b..60357e36 100644 --- a/test/prototypes/GatewayUpgrade.spec.ts +++ b/test/prototypes/GatewayEVMUpgrade.spec.ts @@ -2,24 +2,24 @@ import { expect } from "chai"; import { Contract } from "ethers"; import { ethers, upgrades } from "hardhat"; -describe("Gateway upgrade", function () { +describe("GatewayEVM upgrade", function () { let receiver: Contract; let gateway: Contract; let token: Contract; let custody: Contract; - let owner: any, destination: any, randomSigner: any; + let owner: any, destination: any, randomSigner: any, tssAddress: any; beforeEach(async function () { const TestERC20 = await ethers.getContractFactory("TestERC20"); const Receiver = await ethers.getContractFactory("Receiver"); - const Gateway = await ethers.getContractFactory("Gateway"); + const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); - [owner, destination, randomSigner] = await ethers.getSigners(); + [owner, destination, randomSigner, tssAddress] = await ethers.getSigners(); // Deploy the contracts token = await TestERC20.deploy("Test Token", "TTK"); receiver = await Receiver.deploy(); - gateway = await upgrades.deployProxy(Gateway, [], { + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { initializer: "initialize", kind: "uups", }); @@ -35,15 +35,19 @@ describe("Gateway upgrade", function () { }); it("should upgrade and forward call to Receiver's receiveA function", async function () { + const custodyBeforeUpgrade = await gateway.custody(); + const tssAddressBeforeUpgrade = await gateway.tssAddress(); + // Upgrade Gateway contract // Fail to upgrade if not using owner account - let GatewayUpgradeTest = await ethers.getContractFactory("GatewayUpgradeTest", randomSigner); + let GatewayUpgradeTest = await ethers.getContractFactory("GatewayEVMUpgradeTest", randomSigner); await expect(upgrades.upgradeProxy(gateway.address, GatewayUpgradeTest)).to.be.revertedWith( "Ownable: caller is not the owner" ); // Upgrade with owner account - GatewayUpgradeTest = await ethers.getContractFactory("GatewayUpgradeTest", owner); + GatewayUpgradeTest = await ethers.getContractFactory("GatewayEVMUpgradeTest", owner); + const gatewayUpgradeTest = await upgrades.upgradeProxy(gateway.address, GatewayUpgradeTest); // Forward call @@ -57,10 +61,13 @@ describe("Gateway upgrade", function () { // Call execute on the GatewayV2 contract const tx = await gatewayUpgradeTest.execute(receiver.address, data, { value: value }); - await tx.wait(); // Listen for the event await expect(tx).to.emit(gatewayUpgradeTest, "ExecutedV2").withArgs(receiver.address, value, data); await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gatewayUpgradeTest.address, value, str, num, flag); + + // Check that storage is not changed + expect(await gatewayUpgradeTest.custody()).to.equal(custodyBeforeUpgrade); + expect(await gatewayUpgradeTest.tssAddress()).to.equal(tssAddressBeforeUpgrade); }); }); diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts deleted file mode 100644 index cb6c7bc1..00000000 --- a/test/prototypes/GatewayIntegration.spec.ts +++ /dev/null @@ -1,126 +0,0 @@ -import { expect } from "chai"; -import { Contract } from "ethers"; -import { ethers, upgrades } from "hardhat"; - -describe("Gateway and Receiver", function () { - let receiver: Contract; - let gateway: Contract; - let token: Contract; - let custody: Contract; - let owner: any, destination: any; - - beforeEach(async function () { - const TestERC20 = await ethers.getContractFactory("TestERC20"); - const Receiver = await ethers.getContractFactory("Receiver"); - const Gateway = await ethers.getContractFactory("Gateway"); - const Custody = await ethers.getContractFactory("ERC20CustodyNew"); - [owner, destination] = await ethers.getSigners(); - - // Deploy the contracts - token = await TestERC20.deploy("Test Token", "TTK"); - receiver = await Receiver.deploy(); - gateway = await upgrades.deployProxy(Gateway, [], { - initializer: "initialize", - kind: "uups", - }); - custody = await Custody.deploy(gateway.address); - - gateway.setCustody(custody.address); - - // Mint initial supply to the owner - await token.mint(owner.address, ethers.utils.parseEther("1000")); - - // Transfer some tokens to the custody contract - await token.transfer(custody.address, ethers.utils.parseEther("500")); - }); - - it("should forward call to Receiver's receiveA function", async function () { - const str = "Hello, Hardhat!"; - const num = 42; - const flag = true; - const value = ethers.utils.parseEther("1.0"); - - // Encode the function call data - const data = receiver.interface.encodeFunctionData("receiveA", [str, num, flag]); - - // Call execute on the Gateway contract - const tx = await gateway.execute(receiver.address, data, { value: value }); - await tx.wait(); - - // Listen for the event - await expect(tx).to.emit(gateway, "Executed").withArgs(receiver.address, value, data); - await expect(tx).to.emit(receiver, "ReceivedA").withArgs(gateway.address, value, str, num, flag); - }); - - it("should forward call to Receiver's receiveB function", async function () { - const strs = ["Hello", "Hardhat"]; - const nums = [1, 2, 3]; - const flag = false; - const data = receiver.interface.encodeFunctionData("receiveB", [strs, nums, flag]); - const tx = await gateway.execute(receiver.address, data); - await tx.wait(); - await expect(tx).to.emit(receiver, "ReceivedB").withArgs(gateway.address, strs, nums, flag); - }); - - it("should forward call with withdrawAndCall and give allowance to destination contract", async function () { - const amount = ethers.utils.parseEther("100"); - - // Encode the function call data for receiveC - const data = receiver.interface.encodeFunctionData("receiveC", [amount, token.address, destination.address]); - - // Withdraw and call - const tx = await custody.withdrawAndCall(token.address, receiver.address, amount, data); - await tx.wait(); - - // Verify the event was emitted - await expect(tx) - .to.emit(receiver, "ReceivedC") - .withArgs(gateway.address, amount, token.address, destination.address); - - // Verify that the tokens were transferred to the destination address - const receiverBalance = await token.balanceOf(destination.address); - expect(receiverBalance).to.equal(amount); - - // Verify that the remaining tokens were refunded to the Custody contract - const remainingBalance = await token.balanceOf(custody.address); - expect(remainingBalance).to.equal(ethers.utils.parseEther("400")); - - // Verify that the approval was reset - const allowance = await token.allowance(gateway.address, receiver.address); - expect(allowance).to.equal(0); - }); - - it("should forward call to Receiver's receiveD function", async function () { - const data = receiver.interface.encodeFunctionData("receiveD"); - - // Execute the call - const tx = await gateway.execute(receiver.address, data); - await tx.wait(); - - // Verify the event was emitted - await expect(tx).to.emit(receiver, "ReceivedD").withArgs(gateway.address); - }); - - it("should forward call to Receiver's receiveD function through withdrawAndCall and return ERC20 tokens to custody", async function () { - const amount = ethers.utils.parseEther("100"); - - // Encode the function call data for receiveD - const data = receiver.interface.encodeFunctionData("receiveD"); - - // Withdraw and call - await custody.withdrawAndCall(token.address, receiver.address, amount, data); - - // Verify the event was emitted - await expect(custody.withdrawAndCall(token.address, receiver.address, amount, data)) - .to.emit(receiver, "ReceivedD") - .withArgs(gateway.address); - - // Verify that the remaining tokens were refunded to the Custody contract - const remainingBalance = await token.balanceOf(custody.address); - expect(remainingBalance).to.equal(ethers.utils.parseEther("500")); - - // Verify that the approval was reset - const allowance = await token.allowance(gateway.address, receiver.address); - expect(allowance).to.equal(0); - }); -}); diff --git a/typechain-types/contracts/prototypes/Gateway.ts b/typechain-types/contracts/prototypes/Gateway.ts index 21eda719..5e76a81a 100644 --- a/typechain-types/contracts/prototypes/Gateway.ts +++ b/typechain-types/contracts/prototypes/Gateway.ts @@ -33,12 +33,15 @@ export interface GatewayInterface extends utils.Interface { "custody()": FunctionFragment; "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; - "initialize()": FunctionFragment; + "initialize(address)": FunctionFragment; "owner()": FunctionFragment; "proxiableUUID()": FunctionFragment; "renounceOwnership()": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; "setCustody(address)": FunctionFragment; "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; }; @@ -52,8 +55,11 @@ export interface GatewayInterface extends utils.Interface { | "owner" | "proxiableUUID" | "renounceOwnership" + | "send" + | "sendERC20" | "setCustody" | "transferOwnership" + | "tssAddress" | "upgradeTo" | "upgradeToAndCall" ): FunctionFragment; @@ -74,7 +80,7 @@ export interface GatewayInterface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "initialize", - values?: undefined + values: [PromiseOrValue] ): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData( @@ -85,6 +91,18 @@ export interface GatewayInterface extends utils.Interface { functionFragment: "renounceOwnership", values?: undefined ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; encodeFunctionData( functionFragment: "setCustody", values: [PromiseOrValue] @@ -93,6 +111,10 @@ export interface GatewayInterface extends utils.Interface { functionFragment: "transferOwnership", values: [PromiseOrValue] ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; encodeFunctionData( functionFragment: "upgradeTo", values: [PromiseOrValue] @@ -118,11 +140,14 @@ export interface GatewayInterface extends utils.Interface { functionFragment: "renounceOwnership", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; decodeFunctionResult( functionFragment: "transferOwnership", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; decodeFunctionResult( functionFragment: "upgradeToAndCall", @@ -136,6 +161,8 @@ export interface GatewayInterface extends utils.Interface { "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; "Initialized(uint8)": EventFragment; "OwnershipTransferred(address,address)": EventFragment; + "Send(bytes,uint256)": EventFragment; + "SendERC20(bytes,address,uint256)": EventFragment; "Upgraded(address)": EventFragment; }; @@ -145,6 +172,8 @@ export interface GatewayInterface extends utils.Interface { getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; + getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; } @@ -214,6 +243,26 @@ export type OwnershipTransferredEvent = TypedEvent< export type OwnershipTransferredEventFilter = TypedEventFilter; +export interface SendEventObject { + recipient: string; + amount: BigNumber; +} +export type SendEvent = TypedEvent<[string, BigNumber], SendEventObject>; + +export type SendEventFilter = TypedEventFilter; + +export interface SendERC20EventObject { + recipient: string; + asset: string; + amount: BigNumber; +} +export type SendERC20Event = TypedEvent< + [string, string, BigNumber], + SendERC20EventObject +>; + +export type SendERC20EventFilter = TypedEventFilter; + export interface UpgradedEventObject { implementation: string; } @@ -265,6 +314,7 @@ export interface Gateway extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -276,6 +326,19 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -286,6 +349,8 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise<[string]>; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -315,6 +380,7 @@ export interface Gateway extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -326,6 +392,19 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -336,6 +415,8 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -364,7 +445,10 @@ export interface Gateway extends BaseContract { overrides?: CallOverrides ): Promise; - initialize(overrides?: CallOverrides): Promise; + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; owner(overrides?: CallOverrides): Promise; @@ -372,6 +456,19 @@ export interface Gateway extends BaseContract { renounceOwnership(overrides?: CallOverrides): Promise; + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: CallOverrides @@ -382,6 +479,8 @@ export interface Gateway extends BaseContract { overrides?: CallOverrides ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: CallOverrides @@ -447,6 +546,20 @@ export interface Gateway extends BaseContract { newOwner?: PromiseOrValue | null ): OwnershipTransferredEventFilter; + "Send(bytes,uint256)"(recipient?: null, amount?: null): SendEventFilter; + Send(recipient?: null, amount?: null): SendEventFilter; + + "SendERC20(bytes,address,uint256)"( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + SendERC20( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + "Upgraded(address)"( implementation?: PromiseOrValue | null ): UpgradedEventFilter; @@ -473,6 +586,7 @@ export interface Gateway extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -484,6 +598,19 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -494,6 +621,8 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -524,6 +653,7 @@ export interface Gateway extends BaseContract { ): Promise; initialize( + _tssAddress: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -535,6 +665,19 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -545,6 +688,8 @@ export interface Gateway extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + tssAddress(overrides?: CallOverrides): Promise; + upgradeTo( newImplementation: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } diff --git a/typechain-types/contracts/prototypes/evm/ERC20CustodyNew.ts b/typechain-types/contracts/prototypes/evm/ERC20CustodyNew.ts new file mode 100644 index 00000000..7e4eb491 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ERC20CustodyNew.ts @@ -0,0 +1,245 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ERC20CustodyNewInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "withdraw(address,address,uint256)": FunctionFragment; + "withdrawAndCall(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "gateway" | "withdraw" | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: { + "Withdraw(address,address,uint256)": EventFragment; + "WithdrawAndCall(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + token: string; + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ERC20CustodyNew extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ERC20CustodyNewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Withdraw(address,address,uint256)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/Gateway.ts b/typechain-types/contracts/prototypes/evm/Gateway.ts new file mode 100644 index 00000000..b016bda1 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/Gateway.ts @@ -0,0 +1,704 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayInterface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize(address)": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "send" + | "sendERC20" + | "setCustody" + | "transferOwnership" + | "tssAddress" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Send(bytes,uint256)": EventFragment; + "SendERC20(bytes,address,uint256)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; + getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface SendEventObject { + recipient: string; + amount: BigNumber; +} +export type SendEvent = TypedEvent<[string, BigNumber], SendEventObject>; + +export type SendEventFilter = TypedEventFilter; + +export interface SendERC20EventObject { + recipient: string; + asset: string; + amount: BigNumber; +} +export type SendERC20Event = TypedEvent< + [string, string, BigNumber], + SendERC20EventObject +>; + +export type SendERC20EventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface Gateway extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Send(bytes,uint256)"(recipient?: null, amount?: null): SendEventFilter; + Send(recipient?: null, amount?: null): SendEventFilter; + + "SendERC20(bytes,address,uint256)"( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + SendERC20( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts new file mode 100644 index 00000000..45ca3f7f --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -0,0 +1,852 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayEVMInterface extends utils.Interface { + functions: { + "call(address,bytes)": FunctionFragment; + "custody()": FunctionFragment; + "deposit(address)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall(address,bytes)": FunctionFragment; + "depositAndCall(address,uint256,address,bytes)": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize(address)": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "call" + | "custody" + | "deposit(address)" + | "deposit(address,uint256,address)" + | "depositAndCall(address,bytes)" + | "depositAndCall(address,uint256,address,bytes)" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "transferOwnership" + | "tssAddress" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deposit(address,uint256,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "deposit(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deposit(address,uint256,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise<[string]>; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts new file mode 100644 index 00000000..27f1c7e1 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts @@ -0,0 +1,704 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayEVMUpgradeTestInterface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize(address)": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "send" + | "sendERC20" + | "setCustody" + | "transferOwnership" + | "tssAddress" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Send(bytes,uint256)": EventFragment; + "SendERC20(bytes,address,uint256)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; + getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface SendEventObject { + recipient: string; + amount: BigNumber; +} +export type SendEvent = TypedEvent<[string, BigNumber], SendEventObject>; + +export type SendEventFilter = TypedEventFilter; + +export interface SendERC20EventObject { + recipient: string; + asset: string; + amount: BigNumber; +} +export type SendERC20Event = TypedEvent< + [string, string, BigNumber], + SendERC20EventObject +>; + +export type SendERC20EventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayEVMUpgradeTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMUpgradeTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Send(bytes,uint256)"(recipient?: null, amount?: null): SendEventFilter; + Send(recipient?: null, amount?: null): SendEventFilter; + + "SendERC20(bytes,address,uint256)"( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + SendERC20( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayUpgradeTest.ts b/typechain-types/contracts/prototypes/evm/GatewayUpgradeTest.ts new file mode 100644 index 00000000..e3880b5e --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayUpgradeTest.ts @@ -0,0 +1,704 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayUpgradeTestInterface extends utils.Interface { + functions: { + "custody()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize(address)": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; + "setCustody(address)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "custody" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "send" + | "sendERC20" + | "setCustody" + | "transferOwnership" + | "tssAddress" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "ExecutedV2(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Send(bytes,uint256)": EventFragment; + "SendERC20(bytes,address,uint256)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; + getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface ExecutedV2EventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedV2Event = TypedEvent< + [string, BigNumber, string], + ExecutedV2EventObject +>; + +export type ExecutedV2EventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface SendEventObject { + recipient: string; + amount: BigNumber; +} +export type SendEvent = TypedEvent<[string, BigNumber], SendEventObject>; + +export type SendEventFilter = TypedEventFilter; + +export interface SendERC20EventObject { + recipient: string; + asset: string; + amount: BigNumber; +} +export type SendERC20Event = TypedEvent< + [string, string, BigNumber], + SendERC20EventObject +>; + +export type SendERC20EventFilter = TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayUpgradeTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayUpgradeTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + custody(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "ExecutedV2(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + ExecutedV2( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedV2EventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Send(bytes,uint256)"(recipient?: null, amount?: null): SendEventFilter; + Send(recipient?: null, amount?: null): SendEventFilter; + + "SendERC20(bytes,address,uint256)"( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + SendERC20( + recipient?: null, + asset?: PromiseOrValue | null, + amount?: null + ): SendERC20EventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + custody(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + token: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/Receiver.ts b/typechain-types/contracts/prototypes/evm/Receiver.ts new file mode 100644 index 00000000..075555a0 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/Receiver.ts @@ -0,0 +1,336 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ReceiverInterface extends utils.Interface { + functions: { + "receiveA(string,uint256,bool)": FunctionFragment; + "receiveB(string[],uint256[],bool)": FunctionFragment; + "receiveC(uint256,address,address)": FunctionFragment; + "receiveD()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" | "receiveD" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "receiveA", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "receiveB", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "receiveC", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "receiveD", values?: undefined): string; + + decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveC", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveD", data: BytesLike): Result; + + events: { + "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; + "ReceivedB(address,string[],uint256[],bool)": EventFragment; + "ReceivedC(address,uint256,address,address)": EventFragment; + "ReceivedD(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedC"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedD"): EventFragment; +} + +export interface ReceivedAEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedAEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedAEventObject +>; + +export type ReceivedAEventFilter = TypedEventFilter; + +export interface ReceivedBEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedBEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedBEventObject +>; + +export type ReceivedBEventFilter = TypedEventFilter; + +export interface ReceivedCEventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedCEvent = TypedEvent< + [string, BigNumber, string, string], + ReceivedCEventObject +>; + +export type ReceivedCEventFilter = TypedEventFilter; + +export interface ReceivedDEventObject { + sender: string; +} +export type ReceivedDEvent = TypedEvent<[string], ReceivedDEventObject>; + +export type ReceivedDEventFilter = TypedEventFilter; + +export interface Receiver extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ReceiverInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveD(overrides?: CallOverrides): Promise; + }; + + filters: { + "ReceivedA(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + ReceivedA( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + + "ReceivedB(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + ReceivedB( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + + "ReceivedC(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; + ReceivedC( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; + + "ReceivedD(address)"(sender?: null): ReceivedDEventFilter; + ReceivedD(sender?: null): ReceivedDEventFilter; + }; + + estimateGas: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/TestERC20.ts b/typechain-types/contracts/prototypes/evm/TestERC20.ts new file mode 100644 index 00000000..e72cddfe --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/TestERC20.ts @@ -0,0 +1,501 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface TestERC20Interface extends utils.Interface { + functions: { + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "decimals()": FunctionFragment; + "decreaseAllowance(address,uint256)": FunctionFragment; + "increaseAllowance(address,uint256)": FunctionFragment; + "mint(address,uint256)": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "allowance" + | "approve" + | "balanceOf" + | "decimals" + | "decreaseAllowance" + | "increaseAllowance" + | "mint" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "decreaseAllowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "increaseAllowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "mint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "decreaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "increaseAllowance", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface TestERC20 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: TestERC20Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + }; + + estimateGas: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + decreaseAllowance( + spender: PromiseOrValue, + subtractedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + increaseAllowance( + spender: PromiseOrValue, + addedValue: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts new file mode 100644 index 00000000..356b9286 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -0,0 +1,10 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as interfacesSol from "./interfaces.sol"; +export type { interfacesSol }; +export type { ERC20CustodyNew } from "./ERC20CustodyNew"; +export type { GatewayEVM } from "./GatewayEVM"; +export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; +export type { Receiver } from "./Receiver"; +export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGateway.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGateway.ts new file mode 100644 index 00000000..9eb52ca6 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGateway.ts @@ -0,0 +1,250 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayInterface extends utils.Interface { + functions: { + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "execute" + | "executeWithERC20" + | "send" + | "sendERC20" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + + events: {}; +} + +export interface IGateway extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts new file mode 100644 index 00000000..2c88b298 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts @@ -0,0 +1,250 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMInterface extends utils.Interface { + functions: { + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "send(bytes,uint256)": FunctionFragment; + "sendERC20(bytes,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "execute" + | "executeWithERC20" + | "send" + | "sendERC20" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "send", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sendERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + + events: {}; +} + +export interface IGatewayEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + send( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + sendERC20( + recipient: PromiseOrValue, + asset: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts new file mode 100644 index 00000000..a354144f --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IGatewayEVM } from "./IGatewayEVM"; diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index 8e3200c1..e5dd4614 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -1,10 +1,5 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as interfacesSol from "./interfaces.sol"; -export type { interfacesSol }; -export type { ERC20CustodyNew } from "./ERC20CustodyNew"; -export type { Gateway } from "./Gateway"; -export type { GatewayUpgradeTest } from "./GatewayUpgradeTest"; -export type { Receiver } from "./Receiver"; -export type { TestERC20 } from "./TestERC20"; +import type * as evm from "./evm"; +export type { evm }; diff --git a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts index 60aa0793..8dc23c23 100644 --- a/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "0x608060405234801561001057600080fd5b50604051610a66380380610a668339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b61094f806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b91906106b6565b60405180910390f35b61007e600480360381019061007991906104e7565b6100c0565b005b61009a60048036038101906100959190610494565b610297565b005b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b8473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16856040518363ffffffff1660e01b815260040161011b92919061068d565b602060405180830381600087803b15801561013557600080fd5b505af1158015610149573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061016d919061056f565b5060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b81526004016101cf95949392919061063f565b600060405180830381600087803b1580156101e957600080fd5b505af11580156101fd573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f82011682018060405250810190610226919061059c565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e858585604051610288939291906106ec565b60405180910390a35050505050565b8273ffffffffffffffffffffffffffffffffffffffff1663a9059cbb83836040518363ffffffff1660e01b81526004016102d292919061068d565b602060405180830381600087803b1580156102ec57600080fd5b505af1158015610300573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610324919061056f565b508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb8360405161038291906106d1565b60405180910390a3505050565b60006103a261039d84610743565b61071e565b9050828152602081018484840111156103be576103bd6108b4565b5b6103c9848285610812565b509392505050565b6000813590506103e0816108d4565b92915050565b6000815190506103f5816108eb565b92915050565b60008083601f840112610411576104106108aa565b5b8235905067ffffffffffffffff81111561042e5761042d6108a5565b5b60208301915083600182028301111561044a576104496108af565b5b9250929050565b600082601f830112610466576104656108aa565b5b815161047684826020860161038f565b91505092915050565b60008135905061048e81610902565b92915050565b6000806000606084860312156104ad576104ac6108be565b5b60006104bb868287016103d1565b93505060206104cc868287016103d1565b92505060406104dd8682870161047f565b9150509250925092565b600080600080600060808688031215610503576105026108be565b5b6000610511888289016103d1565b9550506020610522888289016103d1565b94505060406105338882890161047f565b935050606086013567ffffffffffffffff811115610554576105536108b9565b5b610560888289016103fb565b92509250509295509295909350565b600060208284031215610585576105846108be565b5b6000610593848285016103e6565b91505092915050565b6000602082840312156105b2576105b16108be565b5b600082015167ffffffffffffffff8111156105d0576105cf6108b9565b5b6105dc84828501610451565b91505092915050565b6105ee81610785565b82525050565b60006106008385610774565b935061060d838584610803565b610616836108c3565b840190509392505050565b61062a816107cd565b82525050565b610639816107c3565b82525050565b600060808201905061065460008301886105e5565b61066160208301876105e5565b61066e6040830186610630565b81810360608301526106818184866105f4565b90509695505050505050565b60006040820190506106a260008301856105e5565b6106af6020830184610630565b9392505050565b60006020820190506106cb6000830184610621565b92915050565b60006020820190506106e66000830184610630565b92915050565b60006040820190506107016000830186610630565b81810360208301526107148184866105f4565b9050949350505050565b6000610728610739565b90506107348282610845565b919050565b6000604051905090565b600067ffffffffffffffff82111561075e5761075d610876565b5b610767826108c3565b9050602081019050919050565b600082825260208201905092915050565b6000610790826107a3565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006107d8826107df565b9050919050565b60006107ea826107f1565b9050919050565b60006107fc826107a3565b9050919050565b82818337600083830152505050565b60005b83811015610830578082015181840152602081019050610815565b8381111561083f576000848401525b50505050565b61084e826108c3565b810181811067ffffffffffffffff8211171561086d5761086c610876565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b6108dd81610785565b81146108e857600080fd5b50565b6108f481610797565b81146108ff57600080fd5b50565b61090b816107c3565b811461091657600080fd5b5056fea26469706673582212203656518e4aa8f541dde5a4d09490f8b82b1ab5258bd18825341fe0e14e94eab164736f6c63430008070033"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts index 424b3e6f..ff914666 100644 --- a/typechain-types/factories/contracts/prototypes/Gateway__factory.ts +++ b/typechain-types/factories/contracts/prototypes/Gateway__factory.ts @@ -20,6 +20,48 @@ const _abi = [ name: "ExecutionFailed", type: "error", }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, { anonymous: false, inputs: [ @@ -140,6 +182,50 @@ const _abi = [ name: "OwnershipTransferred", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Send", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "SendERC20", + type: "event", + }, { anonymous: false, inputs: [ @@ -264,6 +350,93 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -290,6 +463,19 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, { inputs: [ { @@ -324,7 +510,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts new file mode 100644 index 00000000..74e05a97 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -0,0 +1,196 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ERC20CustodyNew, + ERC20CustodyNewInterface, +} from "../../../../contracts/prototypes/evm/ERC20CustodyNew"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ERC20CustodyNewConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ERC20CustodyNewConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ERC20CustodyNew__factory extends ContractFactory { + constructor(...args: ERC20CustodyNewConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(_gateway, overrides || {}) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, overrides || {}); + } + override attach(address: string): ERC20CustodyNew { + return super.attach(address) as ERC20CustodyNew; + } + override connect(signer: Signer): ERC20CustodyNew__factory { + return super.connect(signer) as ERC20CustodyNew__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ERC20CustodyNewInterface { + return new utils.Interface(_abi) as ERC20CustodyNewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ERC20CustodyNew { + return new Contract(address, _abi, signerOrProvider) as ERC20CustodyNew; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts new file mode 100644 index 00000000..57a384fd --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -0,0 +1,497 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayEVMUpgradeTest, + GatewayEVMUpgradeTestInterface, +} from "../../../../contracts/prototypes/evm/GatewayEVMUpgradeTest"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Send", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "SendERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMUpgradeTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMUpgradeTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVMUpgradeTest__factory extends ContractFactory { + constructor(...args: GatewayEVMUpgradeTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVMUpgradeTest { + return super.attach(address) as GatewayEVMUpgradeTest; + } + override connect(signer: Signer): GatewayEVMUpgradeTest__factory { + return super.connect(signer) as GatewayEVMUpgradeTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMUpgradeTestInterface { + return new utils.Interface(_abi) as GatewayEVMUpgradeTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVMUpgradeTest { + return new Contract( + address, + _abi, + signerOrProvider + ) as GatewayEVMUpgradeTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts new file mode 100644 index 00000000..eb345f93 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -0,0 +1,575 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayEVM, + GatewayEVMInterface, +} from "../../../../contracts/prototypes/evm/GatewayEVM"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVM__factory extends ContractFactory { + constructor(...args: GatewayEVMConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVM { + return super.attach(address) as GatewayEVM; + } + override connect(signer: Signer): GatewayEVM__factory { + return super.connect(signer) as GatewayEVM__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMInterface { + return new utils.Interface(_abi) as GatewayEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVM { + return new Contract(address, _abi, signerOrProvider) as GatewayEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayUpgradeTest__factory.ts new file mode 100644 index 00000000..1bf811e3 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayUpgradeTest__factory.ts @@ -0,0 +1,488 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayUpgradeTest, + GatewayUpgradeTestInterface, +} from "../../../../contracts/prototypes/evm/GatewayUpgradeTest"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedV2", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Send", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "SendERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayUpgradeTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayUpgradeTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayUpgradeTest__factory extends ContractFactory { + constructor(...args: GatewayUpgradeTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayUpgradeTest { + return super.attach(address) as GatewayUpgradeTest; + } + override connect(signer: Signer): GatewayUpgradeTest__factory { + return super.connect(signer) as GatewayUpgradeTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayUpgradeTestInterface { + return new utils.Interface(_abi) as GatewayUpgradeTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayUpgradeTest { + return new Contract(address, _abi, signerOrProvider) as GatewayUpgradeTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/Gateway__factory.ts b/typechain-types/factories/contracts/prototypes/evm/Gateway__factory.ts new file mode 100644 index 00000000..a19f6505 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/Gateway__factory.ts @@ -0,0 +1,488 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + Gateway, + GatewayInterface, +} from "../../../../contracts/prototypes/evm/Gateway"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "SendFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Send", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "SendERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Gateway__factory extends ContractFactory { + constructor(...args: GatewayConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): Gateway { + return super.attach(address) as Gateway; + } + override connect(signer: Signer): Gateway__factory { + return super.connect(signer) as Gateway__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayInterface { + return new utils.Interface(_abi) as GatewayInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Gateway { + return new Contract(address, _abi, signerOrProvider) as Gateway; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts new file mode 100644 index 00000000..7b19442e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts @@ -0,0 +1,251 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + Receiver, + ReceiverInterface, +} from "../../../../contracts/prototypes/evm/Receiver"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedA", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedB", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedC", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedD", + type: "event", + }, + { + inputs: [ + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveA", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveB", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "receiveC", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "receiveD", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ReceiverConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ReceiverConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Receiver__factory extends ContractFactory { + constructor(...args: ReceiverConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): Receiver { + return super.attach(address) as Receiver; + } + override connect(signer: Signer): Receiver__factory { + return super.connect(signer) as Receiver__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ReceiverInterface { + return new utils.Interface(_abi) as ReceiverInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): Receiver { + return new Contract(address, _abi, signerOrProvider) as Receiver; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/TestERC20__factory.ts b/typechain-types/factories/contracts/prototypes/evm/TestERC20__factory.ts new file mode 100644 index 00000000..d6f04373 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/TestERC20__factory.ts @@ -0,0 +1,371 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + TestERC20, + TestERC20Interface, +} from "../../../../contracts/prototypes/evm/TestERC20"; + +const _abi = [ + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "symbol", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "subtractedValue", + type: "uint256", + }, + ], + name: "decreaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "addedValue", + type: "uint256", + }, + ], + name: "increaseAllowance", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "mint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type TestERC20ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: TestERC20ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class TestERC20__factory extends ContractFactory { + constructor(...args: TestERC20ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + name: PromiseOrValue, + symbol: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(name, symbol, overrides || {}) as Promise; + } + override getDeployTransaction( + name: PromiseOrValue, + symbol: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(name, symbol, overrides || {}); + } + override attach(address: string): TestERC20 { + return super.attach(address) as TestERC20; + } + override connect(signer: Signer): TestERC20__factory { + return super.connect(signer) as TestERC20__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): TestERC20Interface { + return new utils.Interface(_abi) as TestERC20Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): TestERC20 { + return new Contract(address, _abi, signerOrProvider) as TestERC20; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts new file mode 100644 index 00000000..d00427f1 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -0,0 +1,9 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as interfacesSol from "./interfaces.sol"; +export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; +export { GatewayEVM__factory } from "./GatewayEVM__factory"; +export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; +export { Receiver__factory } from "./Receiver__factory"; +export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts new file mode 100644 index 00000000..d901f6b5 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts @@ -0,0 +1,125 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVM, + IGatewayEVMInterface, +} from "../../../../../contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGatewayEVM__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMInterface { + return new utils.Interface(_abi) as IGatewayEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVM { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGateway__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGateway__factory.ts new file mode 100644 index 00000000..e612fd3e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGateway__factory.ts @@ -0,0 +1,125 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGateway, + IGatewayInterface, +} from "../../../../../contracts/prototypes/evm/interfaces.sol/IGateway"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "send", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "recipient", + type: "bytes", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "sendERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGateway__factory { + static readonly abi = _abi; + static createInterface(): IGatewayInterface { + return new utils.Interface(_abi) as IGatewayInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGateway { + return new Contract(address, _abi, signerOrProvider) as IGateway; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts new file mode 100644 index 00000000..1b765f1f --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IGatewayEVM__factory } from "./IGatewayEVM__factory"; diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 6fb60d1c..42f56458 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -1,9 +1,4 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as interfacesSol from "./interfaces.sol"; -export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; -export { Gateway__factory } from "./Gateway__factory"; -export { GatewayUpgradeTest__factory } from "./GatewayUpgradeTest__factory"; -export { Receiver__factory } from "./Receiver__factory"; -export { TestERC20__factory } from "./TestERC20__factory"; +export * as evm from "./evm"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index e98d4f69..6c4d8917 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -337,17 +337,17 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "Gateway", + name: "GatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( - name: "GatewayUpgradeTest", + name: "GatewayEVMUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( - name: "IGateway", + name: "IGatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "Receiver", signerOrOptions?: ethers.Signer | FactoryOptions @@ -831,20 +831,20 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "Gateway", + name: "GatewayEVM", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "GatewayUpgradeTest", + name: "GatewayEVMUpgradeTest", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "IGateway", + name: "IGatewayEVM", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "Receiver", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 6f13ad23..8cf703c2 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -156,18 +156,18 @@ export type { ZetaConnectorEth } from "./contracts/evm/ZetaConnector.eth.sol/Zet export { ZetaConnectorEth__factory } from "./factories/contracts/evm/ZetaConnector.eth.sol/ZetaConnectorEth__factory"; export type { ZetaConnectorNonEth } from "./contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth"; export { ZetaConnectorNonEth__factory } from "./factories/contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth__factory"; -export type { ERC20CustodyNew } from "./contracts/prototypes/ERC20CustodyNew"; -export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/ERC20CustodyNew__factory"; -export type { Gateway } from "./contracts/prototypes/Gateway"; -export { Gateway__factory } from "./factories/contracts/prototypes/Gateway__factory"; -export type { GatewayUpgradeTest } from "./contracts/prototypes/GatewayUpgradeTest"; -export { GatewayUpgradeTest__factory } from "./factories/contracts/prototypes/GatewayUpgradeTest__factory"; -export type { IGateway } from "./contracts/prototypes/interfaces.sol/IGateway"; -export { IGateway__factory } from "./factories/contracts/prototypes/interfaces.sol/IGateway__factory"; -export type { Receiver } from "./contracts/prototypes/Receiver"; -export { Receiver__factory } from "./factories/contracts/prototypes/Receiver__factory"; -export type { TestERC20 } from "./contracts/prototypes/TestERC20"; -export { TestERC20__factory } from "./factories/contracts/prototypes/TestERC20__factory"; +export type { ERC20CustodyNew } from "./contracts/prototypes/evm/ERC20CustodyNew"; +export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNew__factory"; +export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; +export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; +export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; +export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; +export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; +export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory"; +export type { Receiver } from "./contracts/prototypes/evm/Receiver"; +export { Receiver__factory } from "./factories/contracts/prototypes/evm/Receiver__factory"; +export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; +export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; From 9a785bce6a01a2ad78624b8be895cfe053b2cc84 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 1 Jul 2024 16:06:29 +0100 Subject: [PATCH 21/86] feat: prototype inbound zevm (#183) Co-authored-by: lumtis --- contracts/prototypes/zevm/GatewayZEVM.sol | 61 + contracts/prototypes/zevm/Sender.sol | 35 + contracts/prototypes/zevm/interfaces.sol | 10 + contracts/zevm/interfaces/IZRC20.sol | 4 +- data/addresses.testnet.json | 13 + .../interfaces/IZRC20.sol/interface.IZRC20.md | 4 +- lib/types.ts | 1 + .../zevm/gatewayzevm.sol/gatewayzevm.go | 1477 +++++++++++++++++ .../zevm/interfaces.sol/igatewayzevm.go | 244 +++ .../prototypes/zevm/sender.sol/sender.go | 276 +++ .../zevm/interfaces/izrc20.sol/izrc20.go | 50 +- .../zevm/systemcontract.sol/systemcontract.go | 2 +- .../systemcontractmock.go | 2 +- pkg/hardhat/console.sol/console.go | 203 +++ test/prototypes/GatewayIntegration.spec.ts | 234 +++ test/prototypes/GatewayZEVM.spec.ts | 114 ++ typechain-types/contracts/prototypes/index.ts | 2 + .../contracts/prototypes/zevm/GatewayZEVM.ts | 583 +++++++ .../contracts/prototypes/zevm/Sender.ts | 210 +++ .../contracts/prototypes/zevm/index.ts | 7 + .../zevm/interfaces.sol/IGatewayZEVM.ts | 209 +++ .../prototypes/zevm/interfaces.sol/index.ts | 4 + .../contracts/zevm/interfaces/IZRC20.ts | 27 +- .../factories/contracts/prototypes/index.ts | 1 + .../prototypes/zevm/GatewayZEVM__factory.ts | 394 +++++ .../prototypes/zevm/Sender__factory.ts | 152 ++ .../contracts/prototypes/zevm/index.ts | 6 + .../interfaces.sol/IGatewayZEVM__factory.ts | 95 ++ .../prototypes/zevm/interfaces.sol/index.ts | 4 + .../SystemContract__factory.ts | 2 +- .../zevm/interfaces/IZRC20__factory.ts | 7 +- .../SystemContractMock__factory.ts | 2 +- typechain-types/hardhat.d.ts | 27 + typechain-types/index.ts | 6 + 34 files changed, 4413 insertions(+), 55 deletions(-) create mode 100644 contracts/prototypes/zevm/GatewayZEVM.sol create mode 100644 contracts/prototypes/zevm/Sender.sol create mode 100644 contracts/prototypes/zevm/interfaces.sol create mode 100644 pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go create mode 100644 pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go create mode 100644 pkg/contracts/prototypes/zevm/sender.sol/sender.go create mode 100644 pkg/hardhat/console.sol/console.go create mode 100644 test/prototypes/GatewayIntegration.spec.ts create mode 100644 test/prototypes/GatewayZEVM.spec.ts create mode 100644 typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts create mode 100644 typechain-types/contracts/prototypes/zevm/Sender.ts create mode 100644 typechain-types/contracts/prototypes/zevm/index.ts create mode 100644 typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts create mode 100644 typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol new file mode 100644 index 00000000..170b2f45 --- /dev/null +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; +import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; +import "../../zevm/interfaces/IZRC20.sol"; + +// The GatewayZEVM contract is the endpoint to call smart contracts on omnichain +// The contract doesn't hold any funds and should never have active allowances +contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { + address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; + + error WithdrawalFailed(); + error InsufficientZRC20Amount(); + error GasFeeTransferFailed(); + + event Call(address indexed sender, bytes indexed receiver, bytes message); + event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); + + /// @custom:oz-upgrades-unsafe-allow constructor + constructor() { + _disableInitializers(); + } + + function initialize() public initializer { + __Ownable_init(); + __UUPSUpgradeable_init(); + } + + function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} + + function _withdraw(uint256 amount, address zrc20) internal returns (uint256) { + (address gasZRC20, uint256 gasFee) = IZRC20(zrc20).withdrawGasFee(); + if (!IZRC20(gasZRC20).transferFrom(msg.sender, FUNGIBLE_MODULE_ADDRESS, gasFee)) { + revert GasFeeTransferFailed(); + } + + IZRC20(zrc20).transferFrom(msg.sender, address(this), amount); + IZRC20(zrc20).burn(amount); + + return gasFee; + } + + // Withdraw ZRC20 tokens to external chain + function withdraw(bytes memory receiver, uint256 amount, address zrc20) external { + uint256 gasFee = _withdraw(amount, zrc20); + emit Withdrawal(msg.sender, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), ""); + } + + // Withdraw ZRC20 tokens and call smart contract on external chain + function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external { + uint256 gasFee = _withdraw(amount, zrc20); + emit Withdrawal(msg.sender, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), message); + } + + // Call smart contract on external chain without asset transfer + function call(bytes memory receiver, bytes calldata message) external { + emit Call(msg.sender, receiver, message); + } +} diff --git a/contracts/prototypes/zevm/Sender.sol b/contracts/prototypes/zevm/Sender.sol new file mode 100644 index 00000000..a495cc66 --- /dev/null +++ b/contracts/prototypes/zevm/Sender.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "./interfaces.sol"; +import "../../zevm/interfaces/IZRC20.sol"; + +contract Sender { + address public gateway; + + constructor(address _gateway) { + gateway = _gateway; + } + + // Call receiver on EVM + function callReceiver(bytes memory receiver, string memory str, uint256 num, bool flag) external { + // Encode the function call to the receiver's receiveA method + bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); + + // Pass encoded call to gateway + IGatewayZEVM(gateway).call(receiver, message); + } + + // Withdraw and call receiver on EVM + function withdrawAndCallReceiver(bytes memory receiver, uint256 amount, address zrc20, string memory str, uint256 num, bool flag) external { + // Encode the function call to the receiver's receiveA method + bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); + + // Approve gateway to withdraw + IZRC20(zrc20).approve(gateway, amount); + + // Pass encoded call to gateway + IGatewayZEVM(gateway).withdrawAndCall(receiver, amount, zrc20, message); + } +} \ No newline at end of file diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/interfaces.sol new file mode 100644 index 00000000..3684976d --- /dev/null +++ b/contracts/prototypes/zevm/interfaces.sol @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +interface IGatewayZEVM { + function withdraw(bytes memory receiver, uint256 amount, address zrc20) external; + + function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external; + + function call(bytes memory receiver, bytes calldata message) external; +} \ No newline at end of file diff --git a/contracts/zevm/interfaces/IZRC20.sol b/contracts/zevm/interfaces/IZRC20.sol index c20da70a..eab06e7f 100644 --- a/contracts/zevm/interfaces/IZRC20.sol +++ b/contracts/zevm/interfaces/IZRC20.sol @@ -20,13 +20,13 @@ interface IZRC20 { function deposit(address to, uint256 amount) external returns (bool); - function burn(address account, uint256 amount) external returns (bool); + function burn(uint256 amount) external returns (bool); function withdraw(bytes memory to, uint256 amount) external returns (bool); function withdrawGasFee() external view returns (address, uint256); - function PROTOCOL_FEE() external view returns (uint256); + function PROTOCOL_FLAT_FEE() external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); diff --git a/data/addresses.testnet.json b/data/addresses.testnet.json index f0c48fcb..cfe36c58 100644 --- a/data/addresses.testnet.json +++ b/data/addresses.testnet.json @@ -197,6 +197,19 @@ "symbol": "tBTC", "type": "zrc20" }, + { + "address": "0x777915D031d1e8144c90D025C594b3b8Bf07a08d", + "asset": "", + "category": "omnichain", + "chain_id": 7001, + "chain_name": "zeta_testnet", + "coin_type": "gas", + "decimals": 18, + "description": "ZetaChain ZRC20 Amoy MATIC-amoy_testnet", + "foreign_chain_id": "80002", + "symbol": "MATIC.AMOY", + "type": "zrc20" + }, { "address": "0x7c8dDa80bbBE1254a7aACf3219EBe1481c6E01d7", "asset": "0x64544969ed7EBf5f083679233325356EbE738930", diff --git a/docs/src/contracts/zevm/interfaces/IZRC20.sol/interface.IZRC20.md b/docs/src/contracts/zevm/interfaces/IZRC20.sol/interface.IZRC20.md index 6c211c96..ee91835d 100644 --- a/docs/src/contracts/zevm/interfaces/IZRC20.sol/interface.IZRC20.md +++ b/docs/src/contracts/zevm/interfaces/IZRC20.sol/interface.IZRC20.md @@ -87,11 +87,11 @@ function withdraw(bytes memory to, uint256 amount) external returns (bool); function withdrawGasFee() external view returns (address, uint256); ``` -### PROTOCOL_FEE +### PROTOCOL_FLAT_FEE ```solidity -function PROTOCOL_FEE() external view returns (uint256); +function PROTOCOL_FLAT_FEE() external view returns (uint256); ``` ## Events diff --git a/lib/types.ts b/lib/types.ts index 28738b51..92971a98 100644 --- a/lib/types.ts +++ b/lib/types.ts @@ -3,6 +3,7 @@ export type ParamSymbol = | "BTC.BTC" | "ETH.ETH" | "gETH" + | "MATIC.AMOY" | "sETH.SEPOLIA" | "tBNB" | "tBTC" diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go new file mode 100644 index 00000000..751c8acf --- /dev/null +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -0,0 +1,1477 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayzevm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. +var GatewayZEVMMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayZEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayZEVMMetaData.ABI instead. +var GatewayZEVMABI = GatewayZEVMMetaData.ABI + +// GatewayZEVMBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayZEVMMetaData.Bin instead. +var GatewayZEVMBin = GatewayZEVMMetaData.Bin + +// DeployGatewayZEVM deploys a new Ethereum contract, binding an instance of GatewayZEVM to it. +func DeployGatewayZEVM(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayZEVM, error) { + parsed, err := GatewayZEVMMetaData.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(GatewayZEVMBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayZEVM{GatewayZEVMCaller: GatewayZEVMCaller{contract: contract}, GatewayZEVMTransactor: GatewayZEVMTransactor{contract: contract}, GatewayZEVMFilterer: GatewayZEVMFilterer{contract: contract}}, nil +} + +// GatewayZEVM is an auto generated Go binding around an Ethereum contract. +type GatewayZEVM struct { + GatewayZEVMCaller // Read-only binding to the contract + GatewayZEVMTransactor // Write-only binding to the contract + GatewayZEVMFilterer // Log filterer for contract events +} + +// GatewayZEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayZEVMCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayZEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayZEVMTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayZEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayZEVMFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayZEVMSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayZEVMSession struct { + Contract *GatewayZEVM // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayZEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayZEVMCallerSession struct { + Contract *GatewayZEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayZEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayZEVMTransactorSession struct { + Contract *GatewayZEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayZEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayZEVMRaw struct { + Contract *GatewayZEVM // Generic contract binding to access the raw methods on +} + +// GatewayZEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayZEVMCallerRaw struct { + Contract *GatewayZEVMCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayZEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayZEVMTransactorRaw struct { + Contract *GatewayZEVMTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayZEVM creates a new instance of GatewayZEVM, bound to a specific deployed contract. +func NewGatewayZEVM(address common.Address, backend bind.ContractBackend) (*GatewayZEVM, error) { + contract, err := bindGatewayZEVM(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayZEVM{GatewayZEVMCaller: GatewayZEVMCaller{contract: contract}, GatewayZEVMTransactor: GatewayZEVMTransactor{contract: contract}, GatewayZEVMFilterer: GatewayZEVMFilterer{contract: contract}}, nil +} + +// NewGatewayZEVMCaller creates a new read-only instance of GatewayZEVM, bound to a specific deployed contract. +func NewGatewayZEVMCaller(address common.Address, caller bind.ContractCaller) (*GatewayZEVMCaller, error) { + contract, err := bindGatewayZEVM(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayZEVMCaller{contract: contract}, nil +} + +// NewGatewayZEVMTransactor creates a new write-only instance of GatewayZEVM, bound to a specific deployed contract. +func NewGatewayZEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayZEVMTransactor, error) { + contract, err := bindGatewayZEVM(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayZEVMTransactor{contract: contract}, nil +} + +// NewGatewayZEVMFilterer creates a new log filterer instance of GatewayZEVM, bound to a specific deployed contract. +func NewGatewayZEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayZEVMFilterer, error) { + contract, err := bindGatewayZEVM(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayZEVMFilterer{contract: contract}, nil +} + +// bindGatewayZEVM binds a generic wrapper to an already deployed contract. +func bindGatewayZEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayZEVMMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayZEVM *GatewayZEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayZEVM.Contract.GatewayZEVMCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayZEVM *GatewayZEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayZEVM.Contract.GatewayZEVMTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayZEVM *GatewayZEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayZEVM.Contract.GatewayZEVMTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayZEVM *GatewayZEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayZEVM.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayZEVM *GatewayZEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayZEVM.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayZEVM *GatewayZEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayZEVM.Contract.contract.Transact(opts, method, params...) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_GatewayZEVM *GatewayZEVMCaller) FUNGIBLEMODULEADDRESS(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayZEVM.contract.Call(opts, &out, "FUNGIBLE_MODULE_ADDRESS") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_GatewayZEVM *GatewayZEVMSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _GatewayZEVM.Contract.FUNGIBLEMODULEADDRESS(&_GatewayZEVM.CallOpts) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_GatewayZEVM *GatewayZEVMCallerSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _GatewayZEVM.Contract.FUNGIBLEMODULEADDRESS(&_GatewayZEVM.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayZEVM *GatewayZEVMCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayZEVM.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayZEVM *GatewayZEVMSession) Owner() (common.Address, error) { + return _GatewayZEVM.Contract.Owner(&_GatewayZEVM.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayZEVM *GatewayZEVMCallerSession) Owner() (common.Address, error) { + return _GatewayZEVM.Contract.Owner(&_GatewayZEVM.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayZEVM *GatewayZEVMCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayZEVM.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayZEVM *GatewayZEVMSession) ProxiableUUID() ([32]byte, error) { + return _GatewayZEVM.Contract.ProxiableUUID(&_GatewayZEVM.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayZEVM *GatewayZEVMCallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayZEVM.Contract.ProxiableUUID(&_GatewayZEVM.CallOpts) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Call(opts *bind.TransactOpts, receiver []byte, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "call", receiver, message) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) Call(receiver []byte, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Call(&_GatewayZEVM.TransactOpts, receiver, message) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Call(receiver []byte, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Call(&_GatewayZEVM.TransactOpts, receiver, message) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "initialize") +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayZEVM *GatewayZEVMSession) Initialize() (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts) +} + +// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// +// Solidity: function initialize() returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Initialize() (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayZEVM *GatewayZEVMTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayZEVM *GatewayZEVMSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayZEVM.Contract.RenounceOwnership(&_GatewayZEVM.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayZEVM.Contract.RenounceOwnership(&_GatewayZEVM.TransactOpts) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayZEVM *GatewayZEVMSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.TransferOwnership(&_GatewayZEVM.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.TransferOwnership(&_GatewayZEVM.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayZEVM *GatewayZEVMSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.UpgradeTo(&_GatewayZEVM.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.UpgradeTo(&_GatewayZEVM.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayZEVM *GatewayZEVMTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayZEVM *GatewayZEVMSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.UpgradeToAndCall(&_GatewayZEVM.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.UpgradeToAndCall(&_GatewayZEVM.TransactOpts, newImplementation, data) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Withdraw(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "withdraw", receiver, amount, zrc20) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_GatewayZEVM *GatewayZEVMSession) Withdraw(receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Withdraw(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Withdraw(receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Withdraw(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) WithdrawAndCall(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "withdrawAndCall", receiver, amount, zrc20, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +} + +// GatewayZEVMAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayZEVM contract. +type GatewayZEVMAdminChangedIterator struct { + Event *GatewayZEVMAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMAdminChanged represents a AdminChanged event raised by the GatewayZEVM contract. +type GatewayZEVMAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayZEVMAdminChangedIterator, error) { + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayZEVMAdminChangedIterator{contract: _GatewayZEVM.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayZEVMAdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMAdminChanged) + if err := _GatewayZEVM.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseAdminChanged(log types.Log) (*GatewayZEVMAdminChanged, error) { + event := new(GatewayZEVMAdminChanged) + if err := _GatewayZEVM.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayZEVM contract. +type GatewayZEVMBeaconUpgradedIterator struct { + Event *GatewayZEVMBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayZEVM contract. +type GatewayZEVMBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayZEVMBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayZEVMBeaconUpgradedIterator{contract: _GatewayZEVM.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayZEVMBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMBeaconUpgraded) + if err := _GatewayZEVM.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayZEVMBeaconUpgraded, error) { + event := new(GatewayZEVMBeaconUpgraded) + if err := _GatewayZEVM.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayZEVM contract. +type GatewayZEVMCallIterator struct { + Event *GatewayZEVMCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMCall represents a Call event raised by the GatewayZEVM contract. +type GatewayZEVMCall struct { + Sender common.Address + Receiver common.Hash + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver [][]byte) (*GatewayZEVMCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayZEVMCallIterator{contract: _GatewayZEVM.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayZEVMCall, sender []common.Address, receiver [][]byte) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMCall) + if err := _GatewayZEVM.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseCall(log types.Log) (*GatewayZEVMCall, error) { + event := new(GatewayZEVMCall) + if err := _GatewayZEVM.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayZEVM contract. +type GatewayZEVMInitializedIterator struct { + Event *GatewayZEVMInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMInitialized represents a Initialized event raised by the GatewayZEVM contract. +type GatewayZEVMInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayZEVMInitializedIterator, error) { + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayZEVMInitializedIterator{contract: _GatewayZEVM.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayZEVMInitialized) (event.Subscription, error) { + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMInitialized) + if err := _GatewayZEVM.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseInitialized(log types.Log) (*GatewayZEVMInitialized, error) { + event := new(GatewayZEVMInitialized) + if err := _GatewayZEVM.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayZEVM contract. +type GatewayZEVMOwnershipTransferredIterator struct { + Event *GatewayZEVMOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayZEVM contract. +type GatewayZEVMOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayZEVMOwnershipTransferredIterator, 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 := _GatewayZEVM.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayZEVMOwnershipTransferredIterator{contract: _GatewayZEVM.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayZEVMOwnershipTransferred, 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 := _GatewayZEVM.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMOwnershipTransferred) + if err := _GatewayZEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayZEVMOwnershipTransferred, error) { + event := new(GatewayZEVMOwnershipTransferred) + if err := _GatewayZEVM.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayZEVM contract. +type GatewayZEVMUpgradedIterator struct { + Event *GatewayZEVMUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMUpgraded represents a Upgraded event raised by the GatewayZEVM contract. +type GatewayZEVMUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayZEVMUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayZEVMUpgradedIterator{contract: _GatewayZEVM.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayZEVMUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMUpgraded) + if err := _GatewayZEVM.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseUpgraded(log types.Log) (*GatewayZEVMUpgraded, error) { + event := new(GatewayZEVMUpgraded) + if err := _GatewayZEVM.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayZEVMWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the GatewayZEVM contract. +type GatewayZEVMWithdrawalIterator struct { + Event *GatewayZEVMWithdrawal // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayZEVMWithdrawalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayZEVMWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayZEVMWithdrawalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayZEVMWithdrawalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayZEVMWithdrawal represents a Withdrawal event raised by the GatewayZEVM contract. +type GatewayZEVMWithdrawal struct { + From common.Address + To []byte + Value *big.Int + Gasfee *big.Int + ProtocolFlatFee *big.Int + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayZEVMWithdrawalIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return &GatewayZEVMWithdrawalIterator{contract: _GatewayZEVM.contract, event: "Withdrawal", logs: logs, sub: sub}, nil +} + +// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayZEVMWithdrawal, from []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayZEVMWithdrawal) + if err := _GatewayZEVM.contract.UnpackLog(event, "Withdrawal", 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 +} + +// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) ParseWithdrawal(log types.Log) (*GatewayZEVMWithdrawal, error) { + event := new(GatewayZEVMWithdrawal) + if err := _GatewayZEVM.contract.UnpackLog(event, "Withdrawal", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go new file mode 100644 index 00000000..01e3975d --- /dev/null +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go @@ -0,0 +1,244 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayZEVMMetaData contains all meta data concerning the IGatewayZEVM contract. +var IGatewayZEVMMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IGatewayZEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayZEVMMetaData.ABI instead. +var IGatewayZEVMABI = IGatewayZEVMMetaData.ABI + +// IGatewayZEVM is an auto generated Go binding around an Ethereum contract. +type IGatewayZEVM struct { + IGatewayZEVMCaller // Read-only binding to the contract + IGatewayZEVMTransactor // Write-only binding to the contract + IGatewayZEVMFilterer // Log filterer for contract events +} + +// IGatewayZEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayZEVMCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayZEVMTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayZEVMFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayZEVMSession struct { + Contract *IGatewayZEVM // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayZEVMCallerSession struct { + Contract *IGatewayZEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayZEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayZEVMTransactorSession struct { + Contract *IGatewayZEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayZEVMRaw struct { + Contract *IGatewayZEVM // Generic contract binding to access the raw methods on +} + +// IGatewayZEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayZEVMCallerRaw struct { + Contract *IGatewayZEVMCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayZEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayZEVMTransactorRaw struct { + Contract *IGatewayZEVMTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayZEVM creates a new instance of IGatewayZEVM, bound to a specific deployed contract. +func NewIGatewayZEVM(address common.Address, backend bind.ContractBackend) (*IGatewayZEVM, error) { + contract, err := bindIGatewayZEVM(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayZEVM{IGatewayZEVMCaller: IGatewayZEVMCaller{contract: contract}, IGatewayZEVMTransactor: IGatewayZEVMTransactor{contract: contract}, IGatewayZEVMFilterer: IGatewayZEVMFilterer{contract: contract}}, nil +} + +// NewIGatewayZEVMCaller creates a new read-only instance of IGatewayZEVM, bound to a specific deployed contract. +func NewIGatewayZEVMCaller(address common.Address, caller bind.ContractCaller) (*IGatewayZEVMCaller, error) { + contract, err := bindIGatewayZEVM(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMCaller{contract: contract}, nil +} + +// NewIGatewayZEVMTransactor creates a new write-only instance of IGatewayZEVM, bound to a specific deployed contract. +func NewIGatewayZEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayZEVMTransactor, error) { + contract, err := bindIGatewayZEVM(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMTransactor{contract: contract}, nil +} + +// NewIGatewayZEVMFilterer creates a new log filterer instance of IGatewayZEVM, bound to a specific deployed contract. +func NewIGatewayZEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayZEVMFilterer, error) { + contract, err := bindIGatewayZEVM(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayZEVMFilterer{contract: contract}, nil +} + +// bindIGatewayZEVM binds a generic wrapper to an already deployed contract. +func bindIGatewayZEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayZEVMMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVM *IGatewayZEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVM.Contract.IGatewayZEVMCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVM *IGatewayZEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.IGatewayZEVMTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVM *IGatewayZEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.IGatewayZEVMTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVM *IGatewayZEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVM.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVM *IGatewayZEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVM *IGatewayZEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.contract.Transact(opts, method, params...) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) Call(opts *bind.TransactOpts, receiver []byte, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "call", receiver, message) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) Call(receiver []byte, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Call(&_IGatewayZEVM.TransactOpts, receiver, message) +} + +// Call is a paid mutator transaction binding the contract method 0x0ac7c44c. +// +// Solidity: function call(bytes receiver, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) Call(receiver []byte, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Call(&_IGatewayZEVM.TransactOpts, receiver, message) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) Withdraw(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "withdraw", receiver, amount, zrc20) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) Withdraw(receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Withdraw(&_IGatewayZEVM.TransactOpts, receiver, amount, zrc20) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x135390f9. +// +// Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) Withdraw(receiver []byte, amount *big.Int, zrc20 common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Withdraw(&_IGatewayZEVM.TransactOpts, receiver, amount, zrc20) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) WithdrawAndCall(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "withdrawAndCall", receiver, amount, zrc20, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.WithdrawAndCall(&_IGatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// +// Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.WithdrawAndCall(&_IGatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +} diff --git a/pkg/contracts/prototypes/zevm/sender.sol/sender.go b/pkg/contracts/prototypes/zevm/sender.sol/sender.go new file mode 100644 index 00000000..430f4c60 --- /dev/null +++ b/pkg/contracts/prototypes/zevm/sender.sol/sender.go @@ -0,0 +1,276 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package sender + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// SenderMetaData contains all meta data concerning the Sender contract. +var SenderMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// SenderABI is the input ABI used to generate the binding from. +// Deprecated: Use SenderMetaData.ABI instead. +var SenderABI = SenderMetaData.ABI + +// SenderBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use SenderMetaData.Bin instead. +var SenderBin = SenderMetaData.Bin + +// DeploySender deploys a new Ethereum contract, binding an instance of Sender to it. +func DeploySender(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address) (common.Address, *types.Transaction, *Sender, error) { + parsed, err := SenderMetaData.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(SenderBin), backend, _gateway) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil +} + +// Sender is an auto generated Go binding around an Ethereum contract. +type Sender struct { + SenderCaller // Read-only binding to the contract + SenderTransactor // Write-only binding to the contract + SenderFilterer // Log filterer for contract events +} + +// SenderCaller is an auto generated read-only Go binding around an Ethereum contract. +type SenderCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SenderTransactor is an auto generated write-only Go binding around an Ethereum contract. +type SenderTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SenderFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type SenderFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SenderSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type SenderSession struct { + Contract *Sender // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SenderCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type SenderCallerSession struct { + Contract *SenderCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// SenderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type SenderTransactorSession struct { + Contract *SenderTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SenderRaw is an auto generated low-level Go binding around an Ethereum contract. +type SenderRaw struct { + Contract *Sender // Generic contract binding to access the raw methods on +} + +// SenderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type SenderCallerRaw struct { + Contract *SenderCaller // Generic read-only contract binding to access the raw methods on +} + +// SenderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type SenderTransactorRaw struct { + Contract *SenderTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewSender creates a new instance of Sender, bound to a specific deployed contract. +func NewSender(address common.Address, backend bind.ContractBackend) (*Sender, error) { + contract, err := bindSender(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil +} + +// NewSenderCaller creates a new read-only instance of Sender, bound to a specific deployed contract. +func NewSenderCaller(address common.Address, caller bind.ContractCaller) (*SenderCaller, error) { + contract, err := bindSender(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &SenderCaller{contract: contract}, nil +} + +// NewSenderTransactor creates a new write-only instance of Sender, bound to a specific deployed contract. +func NewSenderTransactor(address common.Address, transactor bind.ContractTransactor) (*SenderTransactor, error) { + contract, err := bindSender(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &SenderTransactor{contract: contract}, nil +} + +// NewSenderFilterer creates a new log filterer instance of Sender, bound to a specific deployed contract. +func NewSenderFilterer(address common.Address, filterer bind.ContractFilterer) (*SenderFilterer, error) { + contract, err := bindSender(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &SenderFilterer{contract: contract}, nil +} + +// bindSender binds a generic wrapper to an already deployed contract. +func bindSender(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := SenderMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Sender *SenderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Sender.Contract.SenderCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Sender *SenderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Sender.Contract.SenderTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Sender *SenderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Sender.Contract.SenderTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Sender *SenderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Sender.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Sender *SenderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Sender.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Sender *SenderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Sender.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_Sender *SenderCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Sender.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_Sender *SenderSession) Gateway() (common.Address, error) { + return _Sender.Contract.Gateway(&_Sender.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_Sender *SenderCallerSession) Gateway() (common.Address, error) { + return _Sender.Contract.Gateway(&_Sender.CallOpts) +} + +// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. +// +// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() +func (_Sender *SenderTransactor) CallReceiver(opts *bind.TransactOpts, receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.contract.Transact(opts, "callReceiver", receiver, str, num, flag) +} + +// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. +// +// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() +func (_Sender *SenderSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) +} + +// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. +// +// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() +func (_Sender *SenderTransactorSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) +} + +// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. +// +// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() +func (_Sender *SenderTransactor) WithdrawAndCallReceiver(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.contract.Transact(opts, "withdrawAndCallReceiver", receiver, amount, zrc20, str, num, flag) +} + +// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. +// +// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() +func (_Sender *SenderSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) +} + +// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. +// +// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() +func (_Sender *SenderTransactorSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) +} diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go index 65a0da78..c16e5efc 100644 --- a/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go +++ b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go @@ -31,7 +31,7 @@ var ( // IZRC20MetaData contains all meta data concerning the IZRC20 contract. var IZRC20MetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"PROTOCOL_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", } // IZRC20ABI is the input ABI used to generate the binding from. @@ -180,12 +180,12 @@ func (_IZRC20 *IZRC20TransactorRaw) Transact(opts *bind.TransactOpts, method str return _IZRC20.Contract.contract.Transact(opts, method, params...) } -// PROTOCOLFEE is a free data retrieval call binding the contract method 0x0b4501fd. +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. // -// Solidity: function PROTOCOL_FEE() view returns(uint256) -func (_IZRC20 *IZRC20Caller) PROTOCOLFEE(opts *bind.CallOpts) (*big.Int, error) { +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20 *IZRC20Caller) PROTOCOLFLATFEE(opts *bind.CallOpts) (*big.Int, error) { var out []interface{} - err := _IZRC20.contract.Call(opts, &out, "PROTOCOL_FEE") + err := _IZRC20.contract.Call(opts, &out, "PROTOCOL_FLAT_FEE") if err != nil { return *new(*big.Int), err @@ -197,18 +197,18 @@ func (_IZRC20 *IZRC20Caller) PROTOCOLFEE(opts *bind.CallOpts) (*big.Int, error) } -// PROTOCOLFEE is a free data retrieval call binding the contract method 0x0b4501fd. +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. // -// Solidity: function PROTOCOL_FEE() view returns(uint256) -func (_IZRC20 *IZRC20Session) PROTOCOLFEE() (*big.Int, error) { - return _IZRC20.Contract.PROTOCOLFEE(&_IZRC20.CallOpts) +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20 *IZRC20Session) PROTOCOLFLATFEE() (*big.Int, error) { + return _IZRC20.Contract.PROTOCOLFLATFEE(&_IZRC20.CallOpts) } -// PROTOCOLFEE is a free data retrieval call binding the contract method 0x0b4501fd. +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. // -// Solidity: function PROTOCOL_FEE() view returns(uint256) -func (_IZRC20 *IZRC20CallerSession) PROTOCOLFEE() (*big.Int, error) { - return _IZRC20.Contract.PROTOCOLFEE(&_IZRC20.CallOpts) +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20 *IZRC20CallerSession) PROTOCOLFLATFEE() (*big.Int, error) { + return _IZRC20.Contract.PROTOCOLFLATFEE(&_IZRC20.CallOpts) } // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. @@ -357,25 +357,25 @@ func (_IZRC20 *IZRC20TransactorSession) Approve(spender common.Address, amount * return _IZRC20.Contract.Approve(&_IZRC20.TransactOpts, spender, amount) } -// Burn is a paid mutator transaction binding the contract method 0x9dc29fac. +// Burn is a paid mutator transaction binding the contract method 0x42966c68. // -// Solidity: function burn(address account, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) Burn(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "burn", account, amount) +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20 *IZRC20Transactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _IZRC20.contract.Transact(opts, "burn", amount) } -// Burn is a paid mutator transaction binding the contract method 0x9dc29fac. +// Burn is a paid mutator transaction binding the contract method 0x42966c68. // -// Solidity: function burn(address account, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) Burn(account common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Burn(&_IZRC20.TransactOpts, account, amount) +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20 *IZRC20Session) Burn(amount *big.Int) (*types.Transaction, error) { + return _IZRC20.Contract.Burn(&_IZRC20.TransactOpts, amount) } -// Burn is a paid mutator transaction binding the contract method 0x9dc29fac. +// Burn is a paid mutator transaction binding the contract method 0x42966c68. // -// Solidity: function burn(address account, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) Burn(account common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Burn(&_IZRC20.TransactOpts, account, amount) +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20 *IZRC20TransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _IZRC20.Contract.Burn(&_IZRC20.TransactOpts, amount) } // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. diff --git a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go index 1c119082..cc61517b 100644 --- a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go +++ b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go @@ -39,7 +39,7 @@ type ZContext struct { // SystemContractMetaData contains all meta data concerning the SystemContract contract. var SystemContractMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetConnectorZEVM\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setConnectorZEVMAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"erc20\",\"type\":\"address\"}],\"name\":\"setGasZetaPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnectorZEVMAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60c06040523480156200001157600080fd5b50604051620018aa380380620018aa8339818101604052810190620000379190620001ac565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614620000b1576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b82600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b815250507f80699e81136d69cb8367ad52a994e25c722a86da654b561d0c14b61a777e7ac560405160405180910390a15050506200025b565b600081519050620001a68162000241565b92915050565b600080600060608486031215620001c857620001c76200023c565b5b6000620001d88682870162000195565b9350506020620001eb8682870162000195565b9250506040620001fe8682870162000195565b9150509250925092565b600062000215826200021c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200024c8162000208565b81146200025857600080fd5b50565b60805160601c60a05160601c61161c6200028e600039600061051b0152600081816105bd0152610bc5015261161c6000f3fe608060405234801561001057600080fd5b50600436106100f55760003560e01c806397770dff11610097578063c63585cc11610066578063c63585cc1461025e578063d7fd7afb1461028e578063d936a012146102be578063ee2815ba146102dc576100f5565b806397770dff146101ec578063a7cb050714610208578063c39aca3714610224578063c62178ac14610240576100f5565b8063513a9c05116100d3578063513a9c0514610164578063569541b914610194578063842da36d146101b257806391dd645f146101d0576100f5565b80630be15547146100fa5780631f0e251b1461012a5780633ce4a5bc14610146575b600080fd5b610114600480360381019061010f9190611022565b6102f8565b60405161012191906112b1565b60405180910390f35b610144600480360381019061013f9190610ebf565b61032b565b005b61014e6104a8565b60405161015b91906112b1565b60405180910390f35b61017e60048036038101906101799190611022565b6104c0565b60405161018b91906112b1565b60405180910390f35b61019c6104f3565b6040516101a991906112b1565b60405180910390f35b6101ba610519565b6040516101c791906112b1565b60405180910390f35b6101ea60048036038101906101e5919061104f565b61053d565b005b61020660048036038101906102019190610ebf565b610697565b005b610222600480360381019061021d919061108f565b610814565b005b61023e60048036038101906102399190610f6c565b6108e1565b005b610248610b13565b60405161025591906112b1565b60405180910390f35b61027860048036038101906102739190610eec565b610b39565b60405161028591906112b1565b60405180910390f35b6102a860048036038101906102a39190611022565b610bab565b6040516102b5919061134a565b60405180910390f35b6102c6610bc3565b6040516102d391906112b1565b60405180910390f35b6102f660048036038101906102f1919061104f565b610be7565b005b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146103a4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561040b576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f3ade88e3922d64780e1bf4460d364c2970b69da813f9c0c07a1c187b5647636c600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405161049d91906112b1565b60405180910390a150565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b60026020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146105b6576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006106057f0000000000000000000000000000000000000000000000000000000000000000600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684610b39565b9050806002600085815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f0ecec485166da6139b13bb7e033e9446e2d35348e80ebf1180d4afe2dba1704e838260405161068a929190611365565b60405180910390a1505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610710576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610777576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fdba79d534382d1a8ae108e4c8ecb27c6ae42ab8b91d44eedf88bd329f3868d5e600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405161080991906112b1565b60405180910390a150565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461088d576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600080848152602001908152602001600020819055507f49f492222906ac486c3c1401fa545626df1f0c0e5a77a05597ea2ed66af9850d82826040516108d592919061138e565b60405180910390a15050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461095a576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614806109d357503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610a0a576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610a459291906112cc565b602060405180830381600087803b158015610a5f57600080fd5b505af1158015610a73573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a979190610f3f565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610ad99594939291906112f5565b600060405180830381600087803b158015610af357600080fd5b505af1158015610b07573d6000803e3d6000fd5b50505050505050505050565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000806000610b488585610cef565b91509150858282604051602001610b60929190611243565b60405160208183030381529060405280519060200120604051602001610b8792919061126f565b6040516020818303038152906040528051906020012060001c925050509392505050565b60006020528060005260406000206000915090505481565b7f000000000000000000000000000000000000000000000000000000000000000081565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610c60576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806001600084815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd1b36d30f6248e97c473b4d1348ca164a4ef6759022f54a58ec200326c39c45d8282604051610ce3929190611365565b60405180910390a15050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161415610d58576040517fcb1e7cfe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1610610d92578284610d95565b83835b8092508193505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610e04576040517f78b507da00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b9250929050565b600081359050610e1a816115a1565b92915050565b600081519050610e2f816115b8565b92915050565b60008083601f840112610e4b57610e4a61150e565b5b8235905067ffffffffffffffff811115610e6857610e67611509565b5b602083019150836001820283011115610e8457610e8361151d565b5b9250929050565b600060608284031215610ea157610ea0611513565b5b81905092915050565b600081359050610eb9816115cf565b92915050565b600060208284031215610ed557610ed461152c565b5b6000610ee384828501610e0b565b91505092915050565b600080600060608486031215610f0557610f0461152c565b5b6000610f1386828701610e0b565b9350506020610f2486828701610e0b565b9250506040610f3586828701610e0b565b9150509250925092565b600060208284031215610f5557610f5461152c565b5b6000610f6384828501610e20565b91505092915050565b60008060008060008060a08789031215610f8957610f8861152c565b5b600087013567ffffffffffffffff811115610fa757610fa6611522565b5b610fb389828a01610e8b565b9650506020610fc489828a01610e0b565b9550506040610fd589828a01610eaa565b9450506060610fe689828a01610e0b565b935050608087013567ffffffffffffffff81111561100757611006611522565b5b61101389828a01610e35565b92509250509295509295509295565b6000602082840312156110385761103761152c565b5b600061104684828501610eaa565b91505092915050565b600080604083850312156110665761106561152c565b5b600061107485828601610eaa565b925050602061108585828601610e0b565b9150509250929050565b600080604083850312156110a6576110a561152c565b5b60006110b485828601610eaa565b92505060206110c585828601610eaa565b9150509250929050565b6110d881611475565b82525050565b6110e781611475565b82525050565b6110fe6110f982611475565b6114d6565b82525050565b61111561111082611493565b6114e8565b82525050565b600061112783856113b7565b93506111348385846114c7565b61113d83611531565b840190509392505050565b600061115483856113c8565b93506111618385846114c7565b61116a83611531565b840190509392505050565b60006111826020836113d9565b915061118d8261154f565b602082019050919050565b60006111a56001836113d9565b91506111b082611578565b600182019050919050565b6000606083016111ce60008401846113fb565b85830360008701526111e183828461111b565b925050506111f260208401846113e4565b6111ff60208601826110cf565b5061120d604084018461145e565b61121a6040860182611225565b508091505092915050565b61122e816114bd565b82525050565b61123d816114bd565b82525050565b600061124f82856110ed565b60148201915061125f82846110ed565b6014820191508190509392505050565b600061127a82611198565b915061128682856110ed565b6014820191506112968284611104565b6020820191506112a582611175565b91508190509392505050565b60006020820190506112c660008301846110de565b92915050565b60006040820190506112e160008301856110de565b6112ee6020830184611234565b9392505050565b6000608082019050818103600083015261130f81886111bb565b905061131e60208301876110de565b61132b6040830186611234565b818103606083015261133e818486611148565b90509695505050505050565b600060208201905061135f6000830184611234565b92915050565b600060408201905061137a6000830185611234565b61138760208301846110de565b9392505050565b60006040820190506113a36000830185611234565b6113b06020830184611234565b9392505050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b60006113f36020840184610e0b565b905092915050565b6000808335600160200384360303811261141857611417611527565b5b83810192508235915060208301925067ffffffffffffffff8211156114405761143f611504565b5b60018202360384131561145657611455611518565b5b509250929050565b600061146d6020840184610eaa565b905092915050565b60006114808261149d565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60006114e1826114f2565b9050919050565b6000819050919050565b60006114fd82611542565b9050919050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f600082015250565b7fff00000000000000000000000000000000000000000000000000000000000000600082015250565b6115aa81611475565b81146115b557600080fd5b50565b6115c181611487565b81146115cc57600080fd5b50565b6115d8816114bd565b81146115e357600080fd5b5056fea26469706673582212207875ed7b29614b36fed6df17ab4d8319246cc854565244214ea9e3ec60e5598264736f6c63430008070033", } // SystemContractABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go index 884e14e6..0eef1d99 100644 --- a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go +++ b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go @@ -32,7 +32,7 @@ var ( // SystemContractMockMetaData contains all meta data concerning the SystemContractMock contract. var SystemContractMockMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"onCrossChainCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SystemContractMockABI is the input ABI used to generate the binding from. diff --git a/pkg/hardhat/console.sol/console.go b/pkg/hardhat/console.sol/console.go new file mode 100644 index 00000000..9329d210 --- /dev/null +++ b/pkg/hardhat/console.sol/console.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package console + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ConsoleMetaData contains all meta data concerning the Console contract. +var ConsoleMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b984f068e9b45c3f00be7595f7bc61c482d2370eb5a8fa63bd27501c6f9a6d9264736f6c63430008070033", +} + +// ConsoleABI is the input ABI used to generate the binding from. +// Deprecated: Use ConsoleMetaData.ABI instead. +var ConsoleABI = ConsoleMetaData.ABI + +// ConsoleBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ConsoleMetaData.Bin instead. +var ConsoleBin = ConsoleMetaData.Bin + +// DeployConsole deploys a new Ethereum contract, binding an instance of Console to it. +func DeployConsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Console, error) { + parsed, err := ConsoleMetaData.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(ConsoleBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil +} + +// Console is an auto generated Go binding around an Ethereum contract. +type Console struct { + ConsoleCaller // Read-only binding to the contract + ConsoleTransactor // Write-only binding to the contract + ConsoleFilterer // Log filterer for contract events +} + +// ConsoleCaller is an auto generated read-only Go binding around an Ethereum contract. +type ConsoleCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ConsoleTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ConsoleFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ConsoleSession struct { + Contract *Console // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ConsoleCallerSession struct { + Contract *ConsoleCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ConsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ConsoleTransactorSession struct { + Contract *ConsoleTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConsoleRaw is an auto generated low-level Go binding around an Ethereum contract. +type ConsoleRaw struct { + Contract *Console // Generic contract binding to access the raw methods on +} + +// ConsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ConsoleCallerRaw struct { + Contract *ConsoleCaller // Generic read-only contract binding to access the raw methods on +} + +// ConsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ConsoleTransactorRaw struct { + Contract *ConsoleTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewConsole creates a new instance of Console, bound to a specific deployed contract. +func NewConsole(address common.Address, backend bind.ContractBackend) (*Console, error) { + contract, err := bindConsole(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil +} + +// NewConsoleCaller creates a new read-only instance of Console, bound to a specific deployed contract. +func NewConsoleCaller(address common.Address, caller bind.ContractCaller) (*ConsoleCaller, error) { + contract, err := bindConsole(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ConsoleCaller{contract: contract}, nil +} + +// NewConsoleTransactor creates a new write-only instance of Console, bound to a specific deployed contract. +func NewConsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*ConsoleTransactor, error) { + contract, err := bindConsole(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ConsoleTransactor{contract: contract}, nil +} + +// NewConsoleFilterer creates a new log filterer instance of Console, bound to a specific deployed contract. +func NewConsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*ConsoleFilterer, error) { + contract, err := bindConsole(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ConsoleFilterer{contract: contract}, nil +} + +// bindConsole binds a generic wrapper to an already deployed contract. +func bindConsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ConsoleMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Console *ConsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Console.Contract.ConsoleCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Console *ConsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Console.Contract.ConsoleTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Console *ConsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Console.Contract.ConsoleTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Console *ConsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Console.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Console *ConsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Console.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Console *ConsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Console.Contract.contract.Transact(opts, method, params...) +} diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts new file mode 100644 index 00000000..2c529432 --- /dev/null +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -0,0 +1,234 @@ +import { AddressZero } from "@ethersproject/constants"; +import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; +import { SystemContract, ZRC20 } from "@typechain-types"; +import { expect } from "chai"; +import { Contract } from "ethers"; +import { parseEther } from "ethers/lib/utils"; +import { ethers, upgrades } from "hardhat"; + +import { FUNGIBLE_MODULE_ADDRESS } from "../test.helpers"; +const hre = require("hardhat"); + +describe("GatewayEVM GatewayZEVM integration", function () { + // EVM + let receiverEVM: Contract; + let gatewayEVM: Contract; + let token: Contract; + let custody: Contract; + let ownerEVM: any, destination: any, tssAddress: any; + + // ZEVM + let senderZEVM: Contract; + let ZRC20Contract: ZRC20; + let systemContract: SystemContract; + let gatewayZEVM: Contract; + let ownerZEVM: SignerWithAddress; + let addrs: SignerWithAddress[]; + + beforeEach(async function () { + [ownerEVM, ownerZEVM, destination, tssAddress, ...addrs] = await ethers.getSigners(); + // Prepare EVM + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const ReceiverEVM = await ethers.getContractFactory("Receiver"); + const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + receiverEVM = await ReceiverEVM.deploy(); + gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tssAddress.address], { + initializer: "initialize", + kind: "uups", + }); + custody = await Custody.deploy(gatewayEVM.address); + + gatewayEVM.setCustody(custody.address); + + // Mint initial supply to the owner + await token.mint(ownerEVM.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + + // Prepare ZEVM + // Impersonate the fungible module account + await hre.network.provider.request({ + method: "hardhat_impersonateAccount", + params: [FUNGIBLE_MODULE_ADDRESS], + }); + + // Get a signer for the fungible module account + const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); + hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); + + const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); + systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; + + const ZRC20Factory = await ethers.getContractFactory("ZRC20"); + ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( + "TOKEN", + "TKN", + 18, + 1, + 1, + 0, + systemContract.address + )) as ZRC20; + + await systemContract.setGasCoinZRC20(1, ZRC20Contract.address); + await systemContract.setGasPrice(1, ZRC20Contract.address); + + await ZRC20Contract.connect(fungibleModuleSigner).deposit(ownerZEVM.address, parseEther("100")); + + const GatewayZEVM = await ethers.getContractFactory("GatewayZEVM"); + gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [], { + initializer: "initialize", + kind: "uups", + }); + + await ZRC20Contract.connect(ownerZEVM).approve(gatewayZEVM.address, parseEther("100")); + + // including abi of gatewayZEVM events, so hardhat can decode them automatically + const senderArtifact = await hre.artifacts.readArtifact("Sender"); + const gatewayZEVMArtifact = await hre.artifacts.readArtifact("GatewayZEVM"); + const senderABI = [ + ...senderArtifact.abi, + ...gatewayZEVMArtifact.abi.filter((f: ethers.utils.Fragment) => f.type === "event"), + ]; + + const SenderZEVM = new ethers.ContractFactory(senderABI, senderArtifact.bytecode, ownerZEVM); + senderZEVM = await SenderZEVM.deploy(gatewayZEVM.address); + + await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); + }); + + it("should call Receiver contract on EVM from ZEVM account", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data and call on zevm + const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + const callTx = await gatewayZEVM.connect(ownerZEVM).call(ethers.utils.arrayify(addrs[0].address), message); + await expect(callTx).to.emit(gatewayZEVM, "Call").withArgs(ownerZEVM.address, addrs[0].address, message); + + // Get message from events + const callTxReceipt = await callTx.wait(); + const callEvent = callTxReceipt.events[0]; + const callMessage = callEvent.args[2]; + + // Call execute on evm + const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); + + // Listen for the event + await expect(executeTx).to.emit(gatewayEVM, "Executed").withArgs(receiverEVM.address, value, callMessage); + await expect(executeTx).to.emit(receiverEVM, "ReceivedA").withArgs(gatewayEVM.address, value, str, num, flag); + }); + + it("should withdraw and call Receiver contract on EVM from ZEVM account", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Encode the function call data and call on zevm + const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + const callTx = await gatewayZEVM + .connect(ownerZEVM) + .withdrawAndCall(receiverEVM.address, parseEther("1"), ZRC20Contract.address, message); + + await expect(callTx) + .to.emit(gatewayZEVM, "Withdrawal") + .withArgs( + ethers.utils.getAddress(ownerZEVM.address), + receiverEVM.address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + message + ); + + // Get message from events + const callTxReceipt = await callTx.wait(); + const callEvent = callTxReceipt.events.filter((e) => e.event == "Withdrawal")[0]; + const callMessage = callEvent.args[5]; + + // Call execute on evm + const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); + + // Listen for the event + await expect(executeTx).to.emit(gatewayEVM, "Executed").withArgs(receiverEVM.address, value, callMessage); + await expect(executeTx).to.emit(receiverEVM, "ReceivedA").withArgs(gatewayEVM.address, value, str, num, flag); + + const balanceOfAfterWithdrawal = await ZRC20Contract.balanceOf(ownerZEVM.address); + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + }); + + it("should call Receiver contract on EVM from Sender contract on ZEVM", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Call sender function + const callTx = await senderZEVM.connect(ownerZEVM).callReceiver(receiverEVM.address, str, num, flag); + + // Get message from events + const callTxReceipt = await callTx.wait(); + const expectedMessage = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + await expect(callTx) + .to.emit(gatewayZEVM, "Call") + .withArgs(senderZEVM.address, receiverEVM.address, expectedMessage); + + const callEvent = callTxReceipt.events[0]; + const callMessage = callEvent.args[2]; + + // Call execute on evm + const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); + + // Listen for the event + await expect(executeTx).to.emit(gatewayEVM, "Executed").withArgs(receiverEVM.address, value, callMessage); + await expect(executeTx).to.emit(receiverEVM, "ReceivedA").withArgs(gatewayEVM.address, value, str, num, flag); + }); + + it("should withdrawn and call Receiver contract on EVM from Sender contract on ZEVM", async function () { + const str = "Hello, Hardhat!"; + const num = 42; + const flag = true; + const value = ethers.utils.parseEther("1.0"); + + // Call sender function + const callTx = await senderZEVM + .connect(ownerZEVM) + .withdrawAndCallReceiver(receiverEVM.address, parseEther("1"), ZRC20Contract.address, str, num, flag); + + // Get message from events + const callTxReceipt = await callTx.wait(); + const expectedMessage = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + + await expect(callTx) + .to.emit(gatewayZEVM, "Withdrawal") + .withArgs( + ethers.utils.getAddress(senderZEVM.address), + receiverEVM.address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + expectedMessage + ); + + const callEvent = callTxReceipt.events.filter((e) => e.event == "Withdrawal")[0]; + const callMessage = callEvent.args[5]; + + // Call execute on evm + const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); + + // Listen for the event + await expect(executeTx).to.emit(gatewayEVM, "Executed").withArgs(receiverEVM.address, value, callMessage); + await expect(executeTx).to.emit(receiverEVM, "ReceivedA").withArgs(gatewayEVM.address, value, str, num, flag); + + const balanceOfAfterWithdrawal = await ZRC20Contract.balanceOf(senderZEVM.address); + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + }); +}); diff --git a/test/prototypes/GatewayZEVM.spec.ts b/test/prototypes/GatewayZEVM.spec.ts new file mode 100644 index 00000000..92b35275 --- /dev/null +++ b/test/prototypes/GatewayZEVM.spec.ts @@ -0,0 +1,114 @@ +import { AddressZero } from "@ethersproject/constants"; +import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; +import { SystemContract, ZRC20 } from "@typechain-types"; +import { expect } from "chai"; +import { BigNumber, Contract } from "ethers"; +import { parseEther } from "ethers/lib/utils"; +import { ethers, upgrades } from "hardhat"; + +import { FUNGIBLE_MODULE_ADDRESS } from "../test.helpers"; +const hre = require("hardhat"); + +describe("GatewayZEVM inbound", function () { + let ZRC20Contract: ZRC20; + let systemContract: SystemContract; + let gateway: Contract; + let owner: SignerWithAddress; + let addrs: SignerWithAddress[]; + + beforeEach(async () => { + [owner, ...addrs] = await ethers.getSigners(); + + // Impersonate the fungible module account + await hre.network.provider.request({ + method: "hardhat_impersonateAccount", + params: [FUNGIBLE_MODULE_ADDRESS], + }); + + // Get a signer for the fungible module account + const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); + hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); + + const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); + systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; + + const ZRC20Factory = await ethers.getContractFactory("ZRC20"); + ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( + "TOKEN", + "TKN", + 18, + 1, + 1, + 0, + systemContract.address + )) as ZRC20; + + await systemContract.setGasCoinZRC20(1, ZRC20Contract.address); + await systemContract.setGasPrice(1, ZRC20Contract.address); + + await ZRC20Contract.connect(fungibleModuleSigner).deposit(owner.address, parseEther("100")); + + const Gateway = await ethers.getContractFactory("GatewayZEVM"); + gateway = await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + }); + + await ZRC20Contract.connect(owner).approve(gateway.address, parseEther("100")); + }); + + it("should withdraw zrc20 and emit event", async function () { + const tx = await gateway + .connect(owner) + .withdraw(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); + + const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + + await expect(tx) + .to.emit(gateway, "Withdrawal") + .withArgs( + ethers.utils.getAddress(owner.address), + addrs[0].address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + "0x" + ); + }); + + it("should withdraw zrc20 and call and emit event with message", async function () { + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tx = await gateway + .connect(owner) + .withdrawAndCall(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); + + const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + + await expect(tx) + .to.emit(gateway, "Withdrawal") + .withArgs( + ethers.utils.getAddress(owner.address), + addrs[0].address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + message + ); + }); + + it("should call and emit event without asset transfer", async function () { + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tx = await gateway.connect(owner).call(ethers.utils.arrayify(addrs[0].address), message); + await expect(tx) + .to.emit(gateway, "Call") + .withArgs(ethers.utils.getAddress(owner.address), addrs[0].address.toLowerCase(), message); + }); +}); diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index e5dd4614..9efb820b 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -3,3 +3,5 @@ /* eslint-disable */ import type * as evm from "./evm"; export type { evm }; +import type * as zevm from "./zevm"; +export type { zevm }; diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts new file mode 100644 index 00000000..1b88a559 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -0,0 +1,583 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayZEVMInterface extends utils.Interface { + functions: { + "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; + "call(bytes,bytes)": FunctionFragment; + "initialize()": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + "withdraw(bytes,uint256,address)": FunctionFragment; + "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "FUNGIBLE_MODULE_ADDRESS" + | "call" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "transferOwnership" + | "upgradeTo" + | "upgradeToAndCall" + | "withdraw" + | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Call(address,bytes,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface CallEventObject { + sender: string; + receiver: string; + message: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; + message: string; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber, string], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface GatewayZEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayZEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize(overrides?: CallOverrides): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Call(address,bytes,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + message?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + message?: null + ): CallEventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + }; + + estimateGas: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + FUNGIBLE_MODULE_ADDRESS( + overrides?: CallOverrides + ): Promise; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/Sender.ts b/typechain-types/contracts/prototypes/zevm/Sender.ts new file mode 100644 index 00000000..35786b7c --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/Sender.ts @@ -0,0 +1,210 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface SenderInterface extends utils.Interface { + functions: { + "callReceiver(bytes,string,uint256,bool)": FunctionFragment; + "gateway()": FunctionFragment; + "withdrawAndCallReceiver(bytes,uint256,address,string,uint256,bool)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "callReceiver" + | "gateway" + | "withdrawAndCallReceiver" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "callReceiver", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdrawAndCallReceiver", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "callReceiver", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCallReceiver", + data: BytesLike + ): Result; + + events: {}; +} + +export interface Sender extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: SenderInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts new file mode 100644 index 00000000..ae132f5b --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as interfacesSol from "./interfaces.sol"; +export type { interfacesSol }; +export type { GatewayZEVM } from "./GatewayZEVM"; +export type { Sender } from "./Sender"; diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts new file mode 100644 index 00000000..c4041432 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts @@ -0,0 +1,209 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayZEVMInterface extends utils.Interface { + functions: { + "call(bytes,bytes)": FunctionFragment; + "withdraw(bytes,uint256,address)": FunctionFragment; + "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "call" | "withdraw" | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IGatewayZEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts new file mode 100644 index 00000000..43858d59 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IGatewayZEVM } from "./IGatewayZEVM"; diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.ts index 78bc48f4..6052dafa 100644 --- a/typechain-types/contracts/zevm/interfaces/IZRC20.ts +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.ts @@ -29,11 +29,11 @@ import type { export interface IZRC20Interface extends utils.Interface { functions: { - "PROTOCOL_FEE()": FunctionFragment; + "PROTOCOL_FLAT_FEE()": FunctionFragment; "allowance(address,address)": FunctionFragment; "approve(address,uint256)": FunctionFragment; "balanceOf(address)": FunctionFragment; - "burn(address,uint256)": FunctionFragment; + "burn(uint256)": FunctionFragment; "decreaseAllowance(address,uint256)": FunctionFragment; "deposit(address,uint256)": FunctionFragment; "increaseAllowance(address,uint256)": FunctionFragment; @@ -46,7 +46,7 @@ export interface IZRC20Interface extends utils.Interface { getFunction( nameOrSignatureOrTopic: - | "PROTOCOL_FEE" + | "PROTOCOL_FLAT_FEE" | "allowance" | "approve" | "balanceOf" @@ -62,7 +62,7 @@ export interface IZRC20Interface extends utils.Interface { ): FunctionFragment; encodeFunctionData( - functionFragment: "PROTOCOL_FEE", + functionFragment: "PROTOCOL_FLAT_FEE", values?: undefined ): string; encodeFunctionData( @@ -79,7 +79,7 @@ export interface IZRC20Interface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "burn", - values: [PromiseOrValue, PromiseOrValue] + values: [PromiseOrValue] ): string; encodeFunctionData( functionFragment: "decreaseAllowance", @@ -119,7 +119,7 @@ export interface IZRC20Interface extends utils.Interface { ): string; decodeFunctionResult( - functionFragment: "PROTOCOL_FEE", + functionFragment: "PROTOCOL_FLAT_FEE", data: BytesLike ): Result; decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; @@ -278,7 +278,7 @@ export interface IZRC20 extends BaseContract { removeListener: OnEvent; functions: { - PROTOCOL_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; allowance( owner: PromiseOrValue, @@ -298,7 +298,6 @@ export interface IZRC20 extends BaseContract { ): Promise<[BigNumber]>; burn( - account: PromiseOrValue, amount: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -345,7 +344,7 @@ export interface IZRC20 extends BaseContract { withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; }; - PROTOCOL_FEE(overrides?: CallOverrides): Promise; + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; allowance( owner: PromiseOrValue, @@ -365,7 +364,6 @@ export interface IZRC20 extends BaseContract { ): Promise; burn( - account: PromiseOrValue, amount: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -412,7 +410,7 @@ export interface IZRC20 extends BaseContract { withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; callStatic: { - PROTOCOL_FEE(overrides?: CallOverrides): Promise; + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; allowance( owner: PromiseOrValue, @@ -432,7 +430,6 @@ export interface IZRC20 extends BaseContract { ): Promise; burn( - account: PromiseOrValue, amount: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -547,7 +544,7 @@ export interface IZRC20 extends BaseContract { }; estimateGas: { - PROTOCOL_FEE(overrides?: CallOverrides): Promise; + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; allowance( owner: PromiseOrValue, @@ -567,7 +564,6 @@ export interface IZRC20 extends BaseContract { ): Promise; burn( - account: PromiseOrValue, amount: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -615,7 +611,7 @@ export interface IZRC20 extends BaseContract { }; populateTransaction: { - PROTOCOL_FEE(overrides?: CallOverrides): Promise; + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; allowance( owner: PromiseOrValue, @@ -635,7 +631,6 @@ export interface IZRC20 extends BaseContract { ): Promise; burn( - account: PromiseOrValue, amount: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 42f56458..33289123 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -2,3 +2,4 @@ /* tslint:disable */ /* eslint-disable */ export * as evm from "./evm"; +export * as zevm from "./zevm"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts new file mode 100644 index 00000000..5a5efbed --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -0,0 +1,394 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayZEVM, + GatewayZEVMInterface, +} from "../../../../contracts/prototypes/zevm/GatewayZEVM"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientZRC20Amount", + type: "error", + }, + { + inputs: [], + name: "WithdrawalFailed", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + inputs: [], + name: "FUNGIBLE_MODULE_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayZEVMConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayZEVMConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayZEVM__factory extends ContractFactory { + constructor(...args: GatewayZEVMConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayZEVM { + return super.attach(address) as GatewayZEVM; + } + override connect(signer: Signer): GatewayZEVM__factory { + return super.connect(signer) as GatewayZEVM__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayZEVMInterface { + return new utils.Interface(_abi) as GatewayZEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayZEVM { + return new Contract(address, _abi, signerOrProvider) as GatewayZEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts new file mode 100644 index 00000000..603503d6 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts @@ -0,0 +1,152 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + Sender, + SenderInterface, +} from "../../../../contracts/prototypes/zevm/Sender"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "callReceiver", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "withdrawAndCallReceiver", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type SenderConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: SenderConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class Sender__factory extends ContractFactory { + constructor(...args: SenderConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(_gateway, overrides || {}) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, overrides || {}); + } + override attach(address: string): Sender { + return super.attach(address) as Sender; + } + override connect(signer: Signer): Sender__factory { + return super.connect(signer) as Sender__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): SenderInterface { + return new utils.Interface(_abi) as SenderInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Sender { + return new Contract(address, _abi, signerOrProvider) as Sender; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts new file mode 100644 index 00000000..d04ef17c --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as interfacesSol from "./interfaces.sol"; +export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; +export { Sender__factory } from "./Sender__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts new file mode 100644 index 00000000..7d6206b4 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts @@ -0,0 +1,95 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVM, + IGatewayZEVMInterface, +} from "../../../../../contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; + +const _abi = [ + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGatewayZEVM__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMInterface { + return new utils.Interface(_abi) as IGatewayZEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVM { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts new file mode 100644 index 00000000..6c9d09b5 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IGatewayZEVM__factory } from "./IGatewayZEVM__factory"; diff --git a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts index c6481503..a25f7578 100644 --- a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts +++ b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts @@ -429,7 +429,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20__factory.ts index c3ecf326..5e878097 100644 --- a/typechain-types/factories/contracts/zevm/interfaces/IZRC20__factory.ts +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20__factory.ts @@ -163,7 +163,7 @@ const _abi = [ }, { inputs: [], - name: "PROTOCOL_FEE", + name: "PROTOCOL_FLAT_FEE", outputs: [ { internalType: "uint256", @@ -243,11 +243,6 @@ const _abi = [ }, { inputs: [ - { - internalType: "address", - name: "account", - type: "address", - }, { internalType: "uint256", name: "amount", diff --git a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts index f4f16134..73252fb7 100644 --- a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts +++ b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts @@ -332,7 +332,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractMockConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 6c4d8917..cb333a18 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -356,6 +356,18 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayZEVM", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IGatewayZEVM", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "Sender", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -855,6 +867,21 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayZEVM", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IGatewayZEVM", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "Sender", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 8cf703c2..63942633 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -168,6 +168,12 @@ export type { Receiver } from "./contracts/prototypes/evm/Receiver"; export { Receiver__factory } from "./factories/contracts/prototypes/evm/Receiver__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; +export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; +export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; +export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; +export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; +export type { Sender } from "./contracts/prototypes/zevm/Sender"; +export { Sender__factory } from "./factories/contracts/prototypes/zevm/Sender__factory"; export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; From 430992a4bb4e7876c84723a6fd5ef92545bee4fd Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 1 Jul 2024 16:32:00 +0100 Subject: [PATCH 22/86] feat: prototype outbound zevm (#191) Co-authored-by: lumtis --- contracts/prototypes/zevm/GatewayZEVM.sol | 43 + contracts/prototypes/zevm/TestZContract.sol | 19 + contracts/prototypes/zevm/ZRC20New.sol | 298 +++ contracts/prototypes/zevm/interfaces.sol | 24 + .../zevm/gatewayzevm.sol/gatewayzevm.go | 74 +- .../zevm/interfaces.sol/igatewayzevm.go | 72 +- .../prototypes/zevm/sender.sol/sender.go | 2 +- .../zevm/testzcontract.sol/testzcontract.go | 369 ++++ .../zevm/zrc20new.sol/zrc20errors.go | 181 ++ .../prototypes/zevm/zrc20new.sol/zrc20new.go | 1831 +++++++++++++++++ pkg/hardhat/console.sol/console.go | 203 -- test/prototypes/GatewayZEVM.spec.ts | 190 +- .../contracts/prototypes/zevm/GatewayZEVM.ts | 177 ++ .../prototypes/zevm/TestZContract.ts | 175 ++ .../zevm/ZRC20New.sol/ZRC20Errors.ts | 56 + .../prototypes/zevm/ZRC20New.sol/ZRC20New.ts | 854 ++++++++ .../prototypes/zevm/ZRC20New.sol/index.ts | 5 + .../contracts/prototypes/zevm/index.ts | 3 + .../zevm/interfaces.sol/IGatewayZEVM.ts | 182 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 135 +- .../prototypes/zevm/Sender__factory.ts | 2 +- .../prototypes/zevm/TestZContract__factory.ts | 145 ++ .../zevm/ZRC20New.sol/ZRC20Errors__factory.ts | 66 + .../zevm/ZRC20New.sol/ZRC20New__factory.ts | 730 +++++++ .../prototypes/zevm/ZRC20New.sol/index.ts | 5 + .../contracts/prototypes/zevm/index.ts | 2 + .../interfaces.sol/IGatewayZEVM__factory.ts | 123 ++ typechain-types/hardhat.d.ts | 27 + typechain-types/index.ts | 8 +- 29 files changed, 5730 insertions(+), 271 deletions(-) create mode 100644 contracts/prototypes/zevm/TestZContract.sol create mode 100644 contracts/prototypes/zevm/ZRC20New.sol create mode 100644 pkg/contracts/prototypes/zevm/testzcontract.sol/testzcontract.go create mode 100644 pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go create mode 100644 pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go delete mode 100644 pkg/hardhat/console.sol/console.go create mode 100644 typechain-types/contracts/prototypes/zevm/TestZContract.ts create mode 100644 typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors.ts create mode 100644 typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New.ts create mode 100644 typechain-types/contracts/prototypes/zevm/ZRC20New.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/TestZContract__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/index.ts diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 170b2f45..c4a97011 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -5,6 +5,7 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "../../zevm/interfaces/IZRC20.sol"; +import "../../zevm/interfaces/zContract.sol"; // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances @@ -14,6 +15,8 @@ contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error WithdrawalFailed(); error InsufficientZRC20Amount(); error GasFeeTransferFailed(); + error CallerIsNotFungibleModule(); + error InvalidTarget(); event Call(address indexed sender, bytes indexed receiver, bytes message); event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); @@ -58,4 +61,44 @@ contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { function call(bytes memory receiver, bytes calldata message) external { emit Call(msg.sender, receiver, message); } + + // Deposit foreign coins into ZRC20 + function deposit( + address zrc20, + uint256 amount, + address target + ) external { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + if (target == FUNGIBLE_MODULE_ADDRESS || target == address(this)) revert InvalidTarget(); + + IZRC20(zrc20).deposit(target, amount); + } + + // Execute user specified contract on ZEVM + function execute( + zContext calldata context, + address zrc20, + uint256 amount, + address target, + bytes calldata message + ) external { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + + zContract(target).onCrossChainCall(context, zrc20, amount, message); + } + + // Deposit foreign coins into ZRC20 and call user specified contract on ZEVM + function depositAndCall( + zContext calldata context, + address zrc20, + uint256 amount, + address target, + bytes calldata message + ) external { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + if (target == FUNGIBLE_MODULE_ADDRESS || target == address(this)) revert InvalidTarget(); + + IZRC20(zrc20).deposit(target, amount); + zContract(target).onCrossChainCall(context, zrc20, amount, message); + } } diff --git a/contracts/prototypes/zevm/TestZContract.sol b/contracts/prototypes/zevm/TestZContract.sol new file mode 100644 index 00000000..e2aa5743 --- /dev/null +++ b/contracts/prototypes/zevm/TestZContract.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "../../zevm/interfaces/zContract.sol"; + +contract TestZContract is zContract { + event ContextData(bytes origin, address sender, uint256 chainID, address msgSender, string message); + + function onCrossChainCall( + zContext calldata context, + address zrc20, + uint256 amount, + bytes calldata message + ) external override { + string memory decodedMessage = abi.decode(message, (string)); + emit ContextData(context.origin, context.sender, context.chainID, msg.sender, decodedMessage); + } +} \ No newline at end of file diff --git a/contracts/prototypes/zevm/ZRC20New.sol b/contracts/prototypes/zevm/ZRC20New.sol new file mode 100644 index 00000000..d9b6ad37 --- /dev/null +++ b/contracts/prototypes/zevm/ZRC20New.sol @@ -0,0 +1,298 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; +import "../../zevm/Interfaces.sol"; + +/** + * @dev Custom errors for ZRC20 + */ +interface ZRC20Errors { + // @dev: Error thrown when caller is not the fungible module + error CallerIsNotFungibleModule(); + error InvalidSender(); + error GasFeeTransferFailed(); + error ZeroGasCoin(); + error ZeroGasPrice(); + error LowAllowance(); + error LowBalance(); + error ZeroAddress(); +} + +// NOTE: this is exactly the same as ZRC20, except gateway contract address is set at deployment +// and used to allow deposit. This is first version, it might change in the future. +contract ZRC20New is IZRC20, IZRC20Metadata, ZRC20Errors { + /// @notice Fungible address is always the same, maintained at the protocol level + address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; + /// @notice Chain id.abi + uint256 public immutable CHAIN_ID; + /// @notice Coin type, checkout Interfaces.sol. + CoinType public immutable COIN_TYPE; + /// @notice System contract address. + address public SYSTEM_CONTRACT_ADDRESS; + /// @notice Gateway contract address. + address public GATEWAY_CONTRACT_ADDRESS; + /// @notice Gas limit. + uint256 public GAS_LIMIT; + /// @notice Protocol flat fee. + uint256 public PROTOCOL_FLAT_FEE; + + mapping(address => uint256) private _balances; + mapping(address => mapping(address => uint256)) private _allowances; + uint256 private _totalSupply; + string private _name; + string private _symbol; + uint8 private _decimals; + + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } + + /** + * @dev Only fungible module modifier. + */ + modifier onlyFungible() { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + _; + } + + /** + * @dev The only one allowed to deploy new ZRC20 is fungible address. + */ + constructor( + string memory name_, + string memory symbol_, + uint8 decimals_, + uint256 chainid_, + CoinType coinType_, + uint256 gasLimit_, + address systemContractAddress_, + address gatewayContractAddress_ + ) { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + _name = name_; + _symbol = symbol_; + _decimals = decimals_; + CHAIN_ID = chainid_; + COIN_TYPE = coinType_; + GAS_LIMIT = gasLimit_; + SYSTEM_CONTRACT_ADDRESS = systemContractAddress_; + GATEWAY_CONTRACT_ADDRESS = gatewayContractAddress_; + } + + /** + * @dev ZRC20 name + * @return name as string + */ + function name() public view virtual override returns (string memory) { + return _name; + } + + /** + * @dev ZRC20 symbol. + * @return symbol as string. + */ + function symbol() public view virtual override returns (string memory) { + return _symbol; + } + + /** + * @dev ZRC20 decimals. + * @return returns uint8 decimals. + */ + function decimals() public view virtual override returns (uint8) { + return _decimals; + } + + /** + * @dev ZRC20 total supply. + * @return returns uint256 total supply. + */ + function totalSupply() public view virtual override returns (uint256) { + return _totalSupply; + } + + /** + * @dev Returns ZRC20 balance of an account. + * @param account, account address for which balance is requested. + * @return uint256 account balance. + */ + function balanceOf(address account) public view virtual override returns (uint256) { + return _balances[account]; + } + + /** + * @dev Returns ZRC20 balance of an account. + * @param recipient, recipiuent address to which transfer is done. + * @return true/false if transfer succeeded/failed. + */ + function transfer(address recipient, uint256 amount) public virtual override returns (bool) { + _transfer(_msgSender(), recipient, amount); + return true; + } + + /** + * @dev Returns token allowance from owner to spender. + * @param owner, owner address. + * @return uint256 allowance. + */ + function allowance(address owner, address spender) public view virtual override returns (uint256) { + return _allowances[owner][spender]; + } + + /** + * @dev Approves amount transferFrom for spender. + * @param spender, spender address. + * @param amount, amount to approve. + * @return true/false if succeeded/failed. + */ + function approve(address spender, uint256 amount) public virtual override returns (bool) { + _approve(_msgSender(), spender, amount); + return true; + } + + /** + * @dev Transfers tokens from sender to recipient. + * @param sender, sender address. + * @param recipient, recipient address. + * @param amount, amount to transfer. + * @return true/false if succeeded/failed. + */ + function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { + _transfer(sender, recipient, amount); + + uint256 currentAllowance = _allowances[sender][_msgSender()]; + if (currentAllowance < amount) revert LowAllowance(); + + _approve(sender, _msgSender(), currentAllowance - amount); + + return true; + } + + /** + * @dev Burns an amount of tokens. + * @param amount, amount to burn. + * @return true/false if succeeded/failed. + */ + function burn(uint256 amount) external returns (bool) { + _burn(msg.sender, amount); + return true; + } + + function _transfer(address sender, address recipient, uint256 amount) internal virtual { + if (sender == address(0)) revert ZeroAddress(); + if (recipient == address(0)) revert ZeroAddress(); + + uint256 senderBalance = _balances[sender]; + if (senderBalance < amount) revert LowBalance(); + + _balances[sender] = senderBalance - amount; + _balances[recipient] += amount; + + emit Transfer(sender, recipient, amount); + } + + function _mint(address account, uint256 amount) internal virtual { + if (account == address(0)) revert ZeroAddress(); + + _totalSupply += amount; + _balances[account] += amount; + emit Transfer(address(0), account, amount); + } + + function _burn(address account, uint256 amount) internal virtual { + if (account == address(0)) revert ZeroAddress(); + + uint256 accountBalance = _balances[account]; + if (accountBalance < amount) revert LowBalance(); + + _balances[account] = accountBalance - amount; + _totalSupply -= amount; + + emit Transfer(account, address(0), amount); + } + + function _approve(address owner, address spender, uint256 amount) internal virtual { + if (owner == address(0)) revert ZeroAddress(); + if (spender == address(0)) revert ZeroAddress(); + + _allowances[owner][spender] = amount; + emit Approval(owner, spender, amount); + } + + /** + * @dev Deposits corresponding tokens from external chain, only callable by Fungible module. + * @param to, recipient address. + * @param amount, amount to deposit. + * @return true/false if succeeded/failed. + */ + function deposit(address to, uint256 amount) external override returns (bool) { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS && msg.sender != SYSTEM_CONTRACT_ADDRESS && msg.sender != GATEWAY_CONTRACT_ADDRESS) revert InvalidSender(); + _mint(to, amount); + emit Deposit(abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), to, amount); + return true; + } + + /** + * @dev Withdraws gas fees. + * @return returns the ZRC20 address for gas on the same chain of this ZRC20, and calculates the gas fee for withdraw() + */ + function withdrawGasFee() public view override returns (address, uint256) { + address gasZRC20 = ISystem(SYSTEM_CONTRACT_ADDRESS).gasCoinZRC20ByChainId(CHAIN_ID); + if (gasZRC20 == address(0)) { + revert ZeroGasCoin(); + } + uint256 gasPrice = ISystem(SYSTEM_CONTRACT_ADDRESS).gasPriceByChainId(CHAIN_ID); + if (gasPrice == 0) { + revert ZeroGasPrice(); + } + uint256 gasFee = gasPrice * GAS_LIMIT + PROTOCOL_FLAT_FEE; + return (gasZRC20, gasFee); + } + + /** + * @dev Withraws ZRC20 tokens to external chains, this function causes cctx module to send out outbound tx to the outbound chain + * this contract should be given enough allowance of the gas ZRC20 to pay for outbound tx gas fee. + * @param to, recipient address. + * @param amount, amount to deposit. + * @return true/false if succeeded/failed. + */ + function withdraw(bytes memory to, uint256 amount) external override returns (bool) { + (address gasZRC20, uint256 gasFee) = withdrawGasFee(); + if (!IZRC20(gasZRC20).transferFrom(msg.sender, FUNGIBLE_MODULE_ADDRESS, gasFee)) { + revert GasFeeTransferFailed(); + } + _burn(msg.sender, amount); + emit Withdrawal(msg.sender, to, amount, gasFee, PROTOCOL_FLAT_FEE); + return true; + } + + /** + * @dev Updates system contract address. Can only be updated by the fungible module. + * @param addr, new system contract address. + */ + function updateSystemContractAddress(address addr) external onlyFungible { + SYSTEM_CONTRACT_ADDRESS = addr; + emit UpdatedSystemContract(addr); + } + + /** + * @dev Updates gas limit. Can only be updated by the fungible module. + * @param gasLimit, new gas limit. + */ + function updateGasLimit(uint256 gasLimit) external onlyFungible { + GAS_LIMIT = gasLimit; + emit UpdatedGasLimit(gasLimit); + } + + /** + * @dev Updates protocol flat fee. Can only be updated by the fungible module. + * @param protocolFlatFee, new protocol flat fee. + */ + function updateProtocolFlatFee(uint256 protocolFlatFee) external onlyFungible { + PROTOCOL_FLAT_FEE = protocolFlatFee; + emit UpdatedProtocolFlatFee(protocolFlatFee); + } +} diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/interfaces.sol index 3684976d..0ac42801 100644 --- a/contracts/prototypes/zevm/interfaces.sol +++ b/contracts/prototypes/zevm/interfaces.sol @@ -1,10 +1,34 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; +import "../../zevm/interfaces/zContract.sol"; + interface IGatewayZEVM { function withdraw(bytes memory receiver, uint256 amount, address zrc20) external; function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external; function call(bytes memory receiver, bytes calldata message) external; + + function deposit( + address zrc20, + uint256 amount, + address target + ) external; + + function execute( + zContext calldata context, + address zrc20, + uint256 amount, + address target, + bytes calldata message + ) external; + + function depositAndCall( + zContext calldata context, + address zrc20, + uint256 amount, + address target, + bytes calldata message + ) external; } \ No newline at end of file diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 751c8acf..1d59c786 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -29,10 +29,17 @@ var ( _ = abi.ConvertType ) +// ZContext is an auto generated low-level Go binding around an user-defined struct. +type ZContext struct { + Origin []byte + Sender common.Address + ChainID *big.Int +} + // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. @@ -316,6 +323,69 @@ func (_GatewayZEVM *GatewayZEVMTransactorSession) Call(receiver []byte, message return _GatewayZEVM.Contract.Call(&_GatewayZEVM.TransactOpts, receiver, message) } +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Deposit(opts *bind.TransactOpts, zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "deposit", zrc20, amount, target) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_GatewayZEVM *GatewayZEVMSession) Deposit(zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Deposit(&_GatewayZEVM.TransactOpts, zrc20, amount, target) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Deposit(zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Deposit(&_GatewayZEVM.TransactOpts, zrc20, amount, target) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) DepositAndCall(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "depositAndCall", context, zrc20, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Execute(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "execute", context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) Execute(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Execute(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Execute(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Execute(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + // Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. // // Solidity: function initialize() returns() diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go index 01e3975d..7d2b4bda 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go @@ -29,9 +29,16 @@ var ( _ = abi.ConvertType ) +// ZContext is an auto generated low-level Go binding around an user-defined struct. +type ZContext struct { + Origin []byte + Sender common.Address + ChainID *big.Int +} + // IGatewayZEVMMetaData contains all meta data concerning the IGatewayZEVM contract. var IGatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + ABI: "[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", } // IGatewayZEVMABI is the input ABI used to generate the binding from. @@ -201,6 +208,69 @@ func (_IGatewayZEVM *IGatewayZEVMTransactorSession) Call(receiver []byte, messag return _IGatewayZEVM.Contract.Call(&_IGatewayZEVM.TransactOpts, receiver, message) } +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) Deposit(opts *bind.TransactOpts, zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "deposit", zrc20, amount, target) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) Deposit(zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Deposit(&_IGatewayZEVM.TransactOpts, zrc20, amount, target) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address zrc20, uint256 amount, address target) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) Deposit(zrc20 common.Address, amount *big.Int, target common.Address) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Deposit(&_IGatewayZEVM.TransactOpts, zrc20, amount, target) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) DepositAndCall(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "depositAndCall", context, zrc20, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.DepositAndCall(&_IGatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.DepositAndCall(&_IGatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactor) Execute(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.contract.Transact(opts, "execute", context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMSession) Execute(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Execute(&_IGatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + +// Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. +// +// Solidity: function execute((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() +func (_IGatewayZEVM *IGatewayZEVMTransactorSession) Execute(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _IGatewayZEVM.Contract.Execute(&_IGatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +} + // Withdraw is a paid mutator transaction binding the contract method 0x135390f9. // // Solidity: function withdraw(bytes receiver, uint256 amount, address zrc20) returns() diff --git a/pkg/contracts/prototypes/zevm/sender.sol/sender.go b/pkg/contracts/prototypes/zevm/sender.sol/sender.go index 430f4c60..e8dcefeb 100644 --- a/pkg/contracts/prototypes/zevm/sender.sol/sender.go +++ b/pkg/contracts/prototypes/zevm/sender.sol/sender.go @@ -32,7 +32,7 @@ var ( // SenderMetaData contains all meta data concerning the Sender contract. var SenderMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/testzcontract.sol/testzcontract.go b/pkg/contracts/prototypes/zevm/testzcontract.sol/testzcontract.go new file mode 100644 index 00000000..5e4ea675 --- /dev/null +++ b/pkg/contracts/prototypes/zevm/testzcontract.sol/testzcontract.go @@ -0,0 +1,369 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package testzcontract + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZContext is an auto generated low-level Go binding around an user-defined struct. +type ZContext struct { + Origin []byte + Sender common.Address + ChainID *big.Int +} + +// TestZContractMetaData contains all meta data concerning the TestZContract contract. +var TestZContractMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"message\",\"type\":\"string\"}],\"name\":\"ContextData\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"onCrossChainCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// TestZContractABI is the input ABI used to generate the binding from. +// Deprecated: Use TestZContractMetaData.ABI instead. +var TestZContractABI = TestZContractMetaData.ABI + +// TestZContractBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use TestZContractMetaData.Bin instead. +var TestZContractBin = TestZContractMetaData.Bin + +// DeployTestZContract deploys a new Ethereum contract, binding an instance of TestZContract to it. +func DeployTestZContract(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *TestZContract, error) { + parsed, err := TestZContractMetaData.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(TestZContractBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &TestZContract{TestZContractCaller: TestZContractCaller{contract: contract}, TestZContractTransactor: TestZContractTransactor{contract: contract}, TestZContractFilterer: TestZContractFilterer{contract: contract}}, nil +} + +// TestZContract is an auto generated Go binding around an Ethereum contract. +type TestZContract struct { + TestZContractCaller // Read-only binding to the contract + TestZContractTransactor // Write-only binding to the contract + TestZContractFilterer // Log filterer for contract events +} + +// TestZContractCaller is an auto generated read-only Go binding around an Ethereum contract. +type TestZContractCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestZContractTransactor is an auto generated write-only Go binding around an Ethereum contract. +type TestZContractTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestZContractFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type TestZContractFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestZContractSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type TestZContractSession struct { + Contract *TestZContract // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestZContractCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type TestZContractCallerSession struct { + Contract *TestZContractCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// TestZContractTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type TestZContractTransactorSession struct { + Contract *TestZContractTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestZContractRaw is an auto generated low-level Go binding around an Ethereum contract. +type TestZContractRaw struct { + Contract *TestZContract // Generic contract binding to access the raw methods on +} + +// TestZContractCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type TestZContractCallerRaw struct { + Contract *TestZContractCaller // Generic read-only contract binding to access the raw methods on +} + +// TestZContractTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type TestZContractTransactorRaw struct { + Contract *TestZContractTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewTestZContract creates a new instance of TestZContract, bound to a specific deployed contract. +func NewTestZContract(address common.Address, backend bind.ContractBackend) (*TestZContract, error) { + contract, err := bindTestZContract(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &TestZContract{TestZContractCaller: TestZContractCaller{contract: contract}, TestZContractTransactor: TestZContractTransactor{contract: contract}, TestZContractFilterer: TestZContractFilterer{contract: contract}}, nil +} + +// NewTestZContractCaller creates a new read-only instance of TestZContract, bound to a specific deployed contract. +func NewTestZContractCaller(address common.Address, caller bind.ContractCaller) (*TestZContractCaller, error) { + contract, err := bindTestZContract(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &TestZContractCaller{contract: contract}, nil +} + +// NewTestZContractTransactor creates a new write-only instance of TestZContract, bound to a specific deployed contract. +func NewTestZContractTransactor(address common.Address, transactor bind.ContractTransactor) (*TestZContractTransactor, error) { + contract, err := bindTestZContract(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &TestZContractTransactor{contract: contract}, nil +} + +// NewTestZContractFilterer creates a new log filterer instance of TestZContract, bound to a specific deployed contract. +func NewTestZContractFilterer(address common.Address, filterer bind.ContractFilterer) (*TestZContractFilterer, error) { + contract, err := bindTestZContract(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &TestZContractFilterer{contract: contract}, nil +} + +// bindTestZContract binds a generic wrapper to an already deployed contract. +func bindTestZContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := TestZContractMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestZContract *TestZContractRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestZContract.Contract.TestZContractCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestZContract *TestZContractRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestZContract.Contract.TestZContractTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestZContract *TestZContractRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestZContract.Contract.TestZContractTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestZContract *TestZContractCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestZContract.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestZContract *TestZContractTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestZContract.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestZContract *TestZContractTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestZContract.Contract.contract.Transact(opts, method, params...) +} + +// OnCrossChainCall is a paid mutator transaction binding the contract method 0xde43156e. +// +// Solidity: function onCrossChainCall((bytes,address,uint256) context, address zrc20, uint256 amount, bytes message) returns() +func (_TestZContract *TestZContractTransactor) OnCrossChainCall(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, message []byte) (*types.Transaction, error) { + return _TestZContract.contract.Transact(opts, "onCrossChainCall", context, zrc20, amount, message) +} + +// OnCrossChainCall is a paid mutator transaction binding the contract method 0xde43156e. +// +// Solidity: function onCrossChainCall((bytes,address,uint256) context, address zrc20, uint256 amount, bytes message) returns() +func (_TestZContract *TestZContractSession) OnCrossChainCall(context ZContext, zrc20 common.Address, amount *big.Int, message []byte) (*types.Transaction, error) { + return _TestZContract.Contract.OnCrossChainCall(&_TestZContract.TransactOpts, context, zrc20, amount, message) +} + +// OnCrossChainCall is a paid mutator transaction binding the contract method 0xde43156e. +// +// Solidity: function onCrossChainCall((bytes,address,uint256) context, address zrc20, uint256 amount, bytes message) returns() +func (_TestZContract *TestZContractTransactorSession) OnCrossChainCall(context ZContext, zrc20 common.Address, amount *big.Int, message []byte) (*types.Transaction, error) { + return _TestZContract.Contract.OnCrossChainCall(&_TestZContract.TransactOpts, context, zrc20, amount, message) +} + +// TestZContractContextDataIterator is returned from FilterContextData and is used to iterate over the raw logs and unpacked data for ContextData events raised by the TestZContract contract. +type TestZContractContextDataIterator struct { + Event *TestZContractContextData // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestZContractContextDataIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestZContractContextData) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestZContractContextData) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestZContractContextDataIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestZContractContextDataIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestZContractContextData represents a ContextData event raised by the TestZContract contract. +type TestZContractContextData struct { + Origin []byte + Sender common.Address + ChainID *big.Int + MsgSender common.Address + Message string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterContextData is a free log retrieval operation binding the contract event 0xcdc8ee677dc5ebe680fb18cebda5e26ba5ea1f0ba504a47e2a9a2ecb476dc98e. +// +// Solidity: event ContextData(bytes origin, address sender, uint256 chainID, address msgSender, string message) +func (_TestZContract *TestZContractFilterer) FilterContextData(opts *bind.FilterOpts) (*TestZContractContextDataIterator, error) { + + logs, sub, err := _TestZContract.contract.FilterLogs(opts, "ContextData") + if err != nil { + return nil, err + } + return &TestZContractContextDataIterator{contract: _TestZContract.contract, event: "ContextData", logs: logs, sub: sub}, nil +} + +// WatchContextData is a free log subscription operation binding the contract event 0xcdc8ee677dc5ebe680fb18cebda5e26ba5ea1f0ba504a47e2a9a2ecb476dc98e. +// +// Solidity: event ContextData(bytes origin, address sender, uint256 chainID, address msgSender, string message) +func (_TestZContract *TestZContractFilterer) WatchContextData(opts *bind.WatchOpts, sink chan<- *TestZContractContextData) (event.Subscription, error) { + + logs, sub, err := _TestZContract.contract.WatchLogs(opts, "ContextData") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestZContractContextData) + if err := _TestZContract.contract.UnpackLog(event, "ContextData", 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 +} + +// ParseContextData is a log parse operation binding the contract event 0xcdc8ee677dc5ebe680fb18cebda5e26ba5ea1f0ba504a47e2a9a2ecb476dc98e. +// +// Solidity: event ContextData(bytes origin, address sender, uint256 chainID, address msgSender, string message) +func (_TestZContract *TestZContractFilterer) ParseContextData(log types.Log) (*TestZContractContextData, error) { + event := new(TestZContractContextData) + if err := _TestZContract.contract.UnpackLog(event, "ContextData", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go b/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go new file mode 100644 index 00000000..6939b531 --- /dev/null +++ b/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zrc20new + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZRC20ErrorsMetaData contains all meta data concerning the ZRC20Errors contract. +var ZRC20ErrorsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"}]", +} + +// ZRC20ErrorsABI is the input ABI used to generate the binding from. +// Deprecated: Use ZRC20ErrorsMetaData.ABI instead. +var ZRC20ErrorsABI = ZRC20ErrorsMetaData.ABI + +// ZRC20Errors is an auto generated Go binding around an Ethereum contract. +type ZRC20Errors struct { + ZRC20ErrorsCaller // Read-only binding to the contract + ZRC20ErrorsTransactor // Write-only binding to the contract + ZRC20ErrorsFilterer // Log filterer for contract events +} + +// ZRC20ErrorsCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZRC20ErrorsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20ErrorsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZRC20ErrorsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20ErrorsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZRC20ErrorsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20ErrorsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZRC20ErrorsSession struct { + Contract *ZRC20Errors // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20ErrorsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZRC20ErrorsCallerSession struct { + Contract *ZRC20ErrorsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZRC20ErrorsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZRC20ErrorsTransactorSession struct { + Contract *ZRC20ErrorsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20ErrorsRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZRC20ErrorsRaw struct { + Contract *ZRC20Errors // Generic contract binding to access the raw methods on +} + +// ZRC20ErrorsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZRC20ErrorsCallerRaw struct { + Contract *ZRC20ErrorsCaller // Generic read-only contract binding to access the raw methods on +} + +// ZRC20ErrorsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZRC20ErrorsTransactorRaw struct { + Contract *ZRC20ErrorsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZRC20Errors creates a new instance of ZRC20Errors, bound to a specific deployed contract. +func NewZRC20Errors(address common.Address, backend bind.ContractBackend) (*ZRC20Errors, error) { + contract, err := bindZRC20Errors(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZRC20Errors{ZRC20ErrorsCaller: ZRC20ErrorsCaller{contract: contract}, ZRC20ErrorsTransactor: ZRC20ErrorsTransactor{contract: contract}, ZRC20ErrorsFilterer: ZRC20ErrorsFilterer{contract: contract}}, nil +} + +// NewZRC20ErrorsCaller creates a new read-only instance of ZRC20Errors, bound to a specific deployed contract. +func NewZRC20ErrorsCaller(address common.Address, caller bind.ContractCaller) (*ZRC20ErrorsCaller, error) { + contract, err := bindZRC20Errors(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZRC20ErrorsCaller{contract: contract}, nil +} + +// NewZRC20ErrorsTransactor creates a new write-only instance of ZRC20Errors, bound to a specific deployed contract. +func NewZRC20ErrorsTransactor(address common.Address, transactor bind.ContractTransactor) (*ZRC20ErrorsTransactor, error) { + contract, err := bindZRC20Errors(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZRC20ErrorsTransactor{contract: contract}, nil +} + +// NewZRC20ErrorsFilterer creates a new log filterer instance of ZRC20Errors, bound to a specific deployed contract. +func NewZRC20ErrorsFilterer(address common.Address, filterer bind.ContractFilterer) (*ZRC20ErrorsFilterer, error) { + contract, err := bindZRC20Errors(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZRC20ErrorsFilterer{contract: contract}, nil +} + +// bindZRC20Errors binds a generic wrapper to an already deployed contract. +func bindZRC20Errors(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZRC20ErrorsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20Errors *ZRC20ErrorsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20Errors.Contract.ZRC20ErrorsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20Errors *ZRC20ErrorsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20Errors.Contract.ZRC20ErrorsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20Errors *ZRC20ErrorsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20Errors.Contract.ZRC20ErrorsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20Errors *ZRC20ErrorsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20Errors.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20Errors *ZRC20ErrorsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20Errors.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20Errors *ZRC20ErrorsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20Errors.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go b/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go new file mode 100644 index 00000000..6ff40a47 --- /dev/null +++ b/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go @@ -0,0 +1,1831 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zrc20new + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZRC20NewMetaData contains all meta data concerning the ZRC20New contract. +var ZRC20NewMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gatewayContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GATEWAY_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// ZRC20NewABI is the input ABI used to generate the binding from. +// Deprecated: Use ZRC20NewMetaData.ABI instead. +var ZRC20NewABI = ZRC20NewMetaData.ABI + +// ZRC20NewBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZRC20NewMetaData.Bin instead. +var ZRC20NewBin = ZRC20NewMetaData.Bin + +// DeployZRC20New deploys a new Ethereum contract, binding an instance of ZRC20New to it. +func DeployZRC20New(auth *bind.TransactOpts, backend bind.ContractBackend, name_ string, symbol_ string, decimals_ uint8, chainid_ *big.Int, coinType_ uint8, gasLimit_ *big.Int, systemContractAddress_ common.Address, gatewayContractAddress_ common.Address) (common.Address, *types.Transaction, *ZRC20New, error) { + parsed, err := ZRC20NewMetaData.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(ZRC20NewBin), backend, name_, symbol_, decimals_, chainid_, coinType_, gasLimit_, systemContractAddress_, gatewayContractAddress_) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ZRC20New{ZRC20NewCaller: ZRC20NewCaller{contract: contract}, ZRC20NewTransactor: ZRC20NewTransactor{contract: contract}, ZRC20NewFilterer: ZRC20NewFilterer{contract: contract}}, nil +} + +// ZRC20New is an auto generated Go binding around an Ethereum contract. +type ZRC20New struct { + ZRC20NewCaller // Read-only binding to the contract + ZRC20NewTransactor // Write-only binding to the contract + ZRC20NewFilterer // Log filterer for contract events +} + +// ZRC20NewCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZRC20NewCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20NewTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZRC20NewTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20NewFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZRC20NewFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20NewSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZRC20NewSession struct { + Contract *ZRC20New // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20NewCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZRC20NewCallerSession struct { + Contract *ZRC20NewCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZRC20NewTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZRC20NewTransactorSession struct { + Contract *ZRC20NewTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20NewRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZRC20NewRaw struct { + Contract *ZRC20New // Generic contract binding to access the raw methods on +} + +// ZRC20NewCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZRC20NewCallerRaw struct { + Contract *ZRC20NewCaller // Generic read-only contract binding to access the raw methods on +} + +// ZRC20NewTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZRC20NewTransactorRaw struct { + Contract *ZRC20NewTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZRC20New creates a new instance of ZRC20New, bound to a specific deployed contract. +func NewZRC20New(address common.Address, backend bind.ContractBackend) (*ZRC20New, error) { + contract, err := bindZRC20New(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZRC20New{ZRC20NewCaller: ZRC20NewCaller{contract: contract}, ZRC20NewTransactor: ZRC20NewTransactor{contract: contract}, ZRC20NewFilterer: ZRC20NewFilterer{contract: contract}}, nil +} + +// NewZRC20NewCaller creates a new read-only instance of ZRC20New, bound to a specific deployed contract. +func NewZRC20NewCaller(address common.Address, caller bind.ContractCaller) (*ZRC20NewCaller, error) { + contract, err := bindZRC20New(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZRC20NewCaller{contract: contract}, nil +} + +// NewZRC20NewTransactor creates a new write-only instance of ZRC20New, bound to a specific deployed contract. +func NewZRC20NewTransactor(address common.Address, transactor bind.ContractTransactor) (*ZRC20NewTransactor, error) { + contract, err := bindZRC20New(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZRC20NewTransactor{contract: contract}, nil +} + +// NewZRC20NewFilterer creates a new log filterer instance of ZRC20New, bound to a specific deployed contract. +func NewZRC20NewFilterer(address common.Address, filterer bind.ContractFilterer) (*ZRC20NewFilterer, error) { + contract, err := bindZRC20New(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZRC20NewFilterer{contract: contract}, nil +} + +// bindZRC20New binds a generic wrapper to an already deployed contract. +func bindZRC20New(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZRC20NewMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20New *ZRC20NewRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20New.Contract.ZRC20NewCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20New *ZRC20NewRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20New.Contract.ZRC20NewTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20New *ZRC20NewRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20New.Contract.ZRC20NewTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20New *ZRC20NewCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20New.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20New *ZRC20NewTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20New.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20New *ZRC20NewTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20New.Contract.contract.Transact(opts, method, params...) +} + +// CHAINID is a free data retrieval call binding the contract method 0x85e1f4d0. +// +// Solidity: function CHAIN_ID() view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) CHAINID(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "CHAIN_ID") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// CHAINID is a free data retrieval call binding the contract method 0x85e1f4d0. +// +// Solidity: function CHAIN_ID() view returns(uint256) +func (_ZRC20New *ZRC20NewSession) CHAINID() (*big.Int, error) { + return _ZRC20New.Contract.CHAINID(&_ZRC20New.CallOpts) +} + +// CHAINID is a free data retrieval call binding the contract method 0x85e1f4d0. +// +// Solidity: function CHAIN_ID() view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) CHAINID() (*big.Int, error) { + return _ZRC20New.Contract.CHAINID(&_ZRC20New.CallOpts) +} + +// COINTYPE is a free data retrieval call binding the contract method 0xa3413d03. +// +// Solidity: function COIN_TYPE() view returns(uint8) +func (_ZRC20New *ZRC20NewCaller) COINTYPE(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "COIN_TYPE") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// COINTYPE is a free data retrieval call binding the contract method 0xa3413d03. +// +// Solidity: function COIN_TYPE() view returns(uint8) +func (_ZRC20New *ZRC20NewSession) COINTYPE() (uint8, error) { + return _ZRC20New.Contract.COINTYPE(&_ZRC20New.CallOpts) +} + +// COINTYPE is a free data retrieval call binding the contract method 0xa3413d03. +// +// Solidity: function COIN_TYPE() view returns(uint8) +func (_ZRC20New *ZRC20NewCallerSession) COINTYPE() (uint8, error) { + return _ZRC20New.Contract.COINTYPE(&_ZRC20New.CallOpts) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCaller) FUNGIBLEMODULEADDRESS(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "FUNGIBLE_MODULE_ADDRESS") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _ZRC20New.Contract.FUNGIBLEMODULEADDRESS(&_ZRC20New.CallOpts) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCallerSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _ZRC20New.Contract.FUNGIBLEMODULEADDRESS(&_ZRC20New.CallOpts) +} + +// GASLIMIT is a free data retrieval call binding the contract method 0x091d2788. +// +// Solidity: function GAS_LIMIT() view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) GASLIMIT(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "GAS_LIMIT") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GASLIMIT is a free data retrieval call binding the contract method 0x091d2788. +// +// Solidity: function GAS_LIMIT() view returns(uint256) +func (_ZRC20New *ZRC20NewSession) GASLIMIT() (*big.Int, error) { + return _ZRC20New.Contract.GASLIMIT(&_ZRC20New.CallOpts) +} + +// GASLIMIT is a free data retrieval call binding the contract method 0x091d2788. +// +// Solidity: function GAS_LIMIT() view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) GASLIMIT() (*big.Int, error) { + return _ZRC20New.Contract.GASLIMIT(&_ZRC20New.CallOpts) +} + +// GATEWAYCONTRACTADDRESS is a free data retrieval call binding the contract method 0xe2f535b8. +// +// Solidity: function GATEWAY_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCaller) GATEWAYCONTRACTADDRESS(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "GATEWAY_CONTRACT_ADDRESS") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GATEWAYCONTRACTADDRESS is a free data retrieval call binding the contract method 0xe2f535b8. +// +// Solidity: function GATEWAY_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewSession) GATEWAYCONTRACTADDRESS() (common.Address, error) { + return _ZRC20New.Contract.GATEWAYCONTRACTADDRESS(&_ZRC20New.CallOpts) +} + +// GATEWAYCONTRACTADDRESS is a free data retrieval call binding the contract method 0xe2f535b8. +// +// Solidity: function GATEWAY_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCallerSession) GATEWAYCONTRACTADDRESS() (common.Address, error) { + return _ZRC20New.Contract.GATEWAYCONTRACTADDRESS(&_ZRC20New.CallOpts) +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) PROTOCOLFLATFEE(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "PROTOCOL_FLAT_FEE") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_ZRC20New *ZRC20NewSession) PROTOCOLFLATFEE() (*big.Int, error) { + return _ZRC20New.Contract.PROTOCOLFLATFEE(&_ZRC20New.CallOpts) +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) PROTOCOLFLATFEE() (*big.Int, error) { + return _ZRC20New.Contract.PROTOCOLFLATFEE(&_ZRC20New.CallOpts) +} + +// SYSTEMCONTRACTADDRESS is a free data retrieval call binding the contract method 0xf2441b32. +// +// Solidity: function SYSTEM_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCaller) SYSTEMCONTRACTADDRESS(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "SYSTEM_CONTRACT_ADDRESS") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// SYSTEMCONTRACTADDRESS is a free data retrieval call binding the contract method 0xf2441b32. +// +// Solidity: function SYSTEM_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewSession) SYSTEMCONTRACTADDRESS() (common.Address, error) { + return _ZRC20New.Contract.SYSTEMCONTRACTADDRESS(&_ZRC20New.CallOpts) +} + +// SYSTEMCONTRACTADDRESS is a free data retrieval call binding the contract method 0xf2441b32. +// +// Solidity: function SYSTEM_CONTRACT_ADDRESS() view returns(address) +func (_ZRC20New *ZRC20NewCallerSession) SYSTEMCONTRACTADDRESS() (common.Address, error) { + return _ZRC20New.Contract.SYSTEMCONTRACTADDRESS(&_ZRC20New.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ZRC20New *ZRC20NewSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ZRC20New.Contract.Allowance(&_ZRC20New.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ZRC20New.Contract.Allowance(&_ZRC20New.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.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 + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ZRC20New *ZRC20NewSession) BalanceOf(account common.Address) (*big.Int, error) { + return _ZRC20New.Contract.BalanceOf(&_ZRC20New.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _ZRC20New.Contract.BalanceOf(&_ZRC20New.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ZRC20New *ZRC20NewCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ZRC20New *ZRC20NewSession) Decimals() (uint8, error) { + return _ZRC20New.Contract.Decimals(&_ZRC20New.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_ZRC20New *ZRC20NewCallerSession) Decimals() (uint8, error) { + return _ZRC20New.Contract.Decimals(&_ZRC20New.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ZRC20New *ZRC20NewCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ZRC20New *ZRC20NewSession) Name() (string, error) { + return _ZRC20New.Contract.Name(&_ZRC20New.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_ZRC20New *ZRC20NewCallerSession) Name() (string, error) { + return _ZRC20New.Contract.Name(&_ZRC20New.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ZRC20New *ZRC20NewCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ZRC20New *ZRC20NewSession) Symbol() (string, error) { + return _ZRC20New.Contract.Symbol(&_ZRC20New.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_ZRC20New *ZRC20NewCallerSession) Symbol() (string, error) { + return _ZRC20New.Contract.Symbol(&_ZRC20New.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ZRC20New *ZRC20NewCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _ZRC20New.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ZRC20New *ZRC20NewSession) TotalSupply() (*big.Int, error) { + return _ZRC20New.Contract.TotalSupply(&_ZRC20New.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ZRC20New *ZRC20NewCallerSession) TotalSupply() (*big.Int, error) { + return _ZRC20New.Contract.TotalSupply(&_ZRC20New.CallOpts) +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_ZRC20New *ZRC20NewCaller) WithdrawGasFee(opts *bind.CallOpts) (common.Address, *big.Int, error) { + var out []interface{} + err := _ZRC20New.contract.Call(opts, &out, "withdrawGasFee") + + if err != nil { + return *new(common.Address), *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return out0, out1, err + +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_ZRC20New *ZRC20NewSession) WithdrawGasFee() (common.Address, *big.Int, error) { + return _ZRC20New.Contract.WithdrawGasFee(&_ZRC20New.CallOpts) +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_ZRC20New *ZRC20NewCallerSession) WithdrawGasFee() (common.Address, *big.Int, error) { + return _ZRC20New.Contract.WithdrawGasFee(&_ZRC20New.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Approve(&_ZRC20New.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Approve(&_ZRC20New.TransactOpts, spender, amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "burn", amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Burn(&_ZRC20New.TransactOpts, amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Burn(&_ZRC20New.TransactOpts, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) Deposit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "deposit", to, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Deposit(&_ZRC20New.TransactOpts, to, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Deposit(&_ZRC20New.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "transfer", recipient, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Transfer(&_ZRC20New.TransactOpts, recipient, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Transfer(&_ZRC20New.TransactOpts, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "transferFrom", sender, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.TransferFrom(&_ZRC20New.TransactOpts, sender, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.TransferFrom(&_ZRC20New.TransactOpts, sender, recipient, amount) +} + +// UpdateGasLimit is a paid mutator transaction binding the contract method 0xf687d12a. +// +// Solidity: function updateGasLimit(uint256 gasLimit) returns() +func (_ZRC20New *ZRC20NewTransactor) UpdateGasLimit(opts *bind.TransactOpts, gasLimit *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "updateGasLimit", gasLimit) +} + +// UpdateGasLimit is a paid mutator transaction binding the contract method 0xf687d12a. +// +// Solidity: function updateGasLimit(uint256 gasLimit) returns() +func (_ZRC20New *ZRC20NewSession) UpdateGasLimit(gasLimit *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateGasLimit(&_ZRC20New.TransactOpts, gasLimit) +} + +// UpdateGasLimit is a paid mutator transaction binding the contract method 0xf687d12a. +// +// Solidity: function updateGasLimit(uint256 gasLimit) returns() +func (_ZRC20New *ZRC20NewTransactorSession) UpdateGasLimit(gasLimit *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateGasLimit(&_ZRC20New.TransactOpts, gasLimit) +} + +// UpdateProtocolFlatFee is a paid mutator transaction binding the contract method 0xeddeb123. +// +// Solidity: function updateProtocolFlatFee(uint256 protocolFlatFee) returns() +func (_ZRC20New *ZRC20NewTransactor) UpdateProtocolFlatFee(opts *bind.TransactOpts, protocolFlatFee *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "updateProtocolFlatFee", protocolFlatFee) +} + +// UpdateProtocolFlatFee is a paid mutator transaction binding the contract method 0xeddeb123. +// +// Solidity: function updateProtocolFlatFee(uint256 protocolFlatFee) returns() +func (_ZRC20New *ZRC20NewSession) UpdateProtocolFlatFee(protocolFlatFee *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateProtocolFlatFee(&_ZRC20New.TransactOpts, protocolFlatFee) +} + +// UpdateProtocolFlatFee is a paid mutator transaction binding the contract method 0xeddeb123. +// +// Solidity: function updateProtocolFlatFee(uint256 protocolFlatFee) returns() +func (_ZRC20New *ZRC20NewTransactorSession) UpdateProtocolFlatFee(protocolFlatFee *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateProtocolFlatFee(&_ZRC20New.TransactOpts, protocolFlatFee) +} + +// UpdateSystemContractAddress is a paid mutator transaction binding the contract method 0xc835d7cc. +// +// Solidity: function updateSystemContractAddress(address addr) returns() +func (_ZRC20New *ZRC20NewTransactor) UpdateSystemContractAddress(opts *bind.TransactOpts, addr common.Address) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "updateSystemContractAddress", addr) +} + +// UpdateSystemContractAddress is a paid mutator transaction binding the contract method 0xc835d7cc. +// +// Solidity: function updateSystemContractAddress(address addr) returns() +func (_ZRC20New *ZRC20NewSession) UpdateSystemContractAddress(addr common.Address) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateSystemContractAddress(&_ZRC20New.TransactOpts, addr) +} + +// UpdateSystemContractAddress is a paid mutator transaction binding the contract method 0xc835d7cc. +// +// Solidity: function updateSystemContractAddress(address addr) returns() +func (_ZRC20New *ZRC20NewTransactorSession) UpdateSystemContractAddress(addr common.Address) (*types.Transaction, error) { + return _ZRC20New.Contract.UpdateSystemContractAddress(&_ZRC20New.TransactOpts, addr) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactor) Withdraw(opts *bind.TransactOpts, to []byte, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.contract.Transact(opts, "withdraw", to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Withdraw(&_ZRC20New.TransactOpts, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_ZRC20New *ZRC20NewTransactorSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { + return _ZRC20New.Contract.Withdraw(&_ZRC20New.TransactOpts, to, amount) +} + +// ZRC20NewApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ZRC20New contract. +type ZRC20NewApprovalIterator struct { + Event *ZRC20NewApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewApproval represents a Approval event raised by the ZRC20New contract. +type ZRC20NewApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ZRC20NewApprovalIterator, 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 := _ZRC20New.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &ZRC20NewApprovalIterator{contract: _ZRC20New.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ZRC20NewApproval, 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 := _ZRC20New.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: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewApproval) + if err := _ZRC20New.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) ParseApproval(log types.Log) (*ZRC20NewApproval, error) { + event := new(ZRC20NewApproval) + if err := _ZRC20New.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the ZRC20New contract. +type ZRC20NewDepositIterator struct { + Event *ZRC20NewDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewDeposit represents a Deposit event raised by the ZRC20New contract. +type ZRC20NewDeposit struct { + From []byte + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) FilterDeposit(opts *bind.FilterOpts, to []common.Address) (*ZRC20NewDepositIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZRC20New.contract.FilterLogs(opts, "Deposit", toRule) + if err != nil { + return nil, err + } + return &ZRC20NewDepositIterator{contract: _ZRC20New.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *ZRC20NewDeposit, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZRC20New.contract.WatchLogs(opts, "Deposit", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewDeposit) + if err := _ZRC20New.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) ParseDeposit(log types.Log) (*ZRC20NewDeposit, error) { + event := new(ZRC20NewDeposit) + if err := _ZRC20New.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ZRC20New contract. +type ZRC20NewTransferIterator struct { + Event *ZRC20NewTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewTransfer represents a Transfer event raised by the ZRC20New contract. +type ZRC20NewTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ZRC20NewTransferIterator, 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 := _ZRC20New.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ZRC20NewTransferIterator{contract: _ZRC20New.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ZRC20NewTransfer, 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 := _ZRC20New.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: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewTransfer) + if err := _ZRC20New.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20New *ZRC20NewFilterer) ParseTransfer(log types.Log) (*ZRC20NewTransfer, error) { + event := new(ZRC20NewTransfer) + if err := _ZRC20New.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewUpdatedGasLimitIterator is returned from FilterUpdatedGasLimit and is used to iterate over the raw logs and unpacked data for UpdatedGasLimit events raised by the ZRC20New contract. +type ZRC20NewUpdatedGasLimitIterator struct { + Event *ZRC20NewUpdatedGasLimit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewUpdatedGasLimitIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedGasLimit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedGasLimit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewUpdatedGasLimitIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewUpdatedGasLimitIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewUpdatedGasLimit represents a UpdatedGasLimit event raised by the ZRC20New contract. +type ZRC20NewUpdatedGasLimit struct { + GasLimit *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedGasLimit is a free log retrieval operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20New *ZRC20NewFilterer) FilterUpdatedGasLimit(opts *bind.FilterOpts) (*ZRC20NewUpdatedGasLimitIterator, error) { + + logs, sub, err := _ZRC20New.contract.FilterLogs(opts, "UpdatedGasLimit") + if err != nil { + return nil, err + } + return &ZRC20NewUpdatedGasLimitIterator{contract: _ZRC20New.contract, event: "UpdatedGasLimit", logs: logs, sub: sub}, nil +} + +// WatchUpdatedGasLimit is a free log subscription operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20New *ZRC20NewFilterer) WatchUpdatedGasLimit(opts *bind.WatchOpts, sink chan<- *ZRC20NewUpdatedGasLimit) (event.Subscription, error) { + + logs, sub, err := _ZRC20New.contract.WatchLogs(opts, "UpdatedGasLimit") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewUpdatedGasLimit) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedGasLimit", 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 +} + +// ParseUpdatedGasLimit is a log parse operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20New *ZRC20NewFilterer) ParseUpdatedGasLimit(log types.Log) (*ZRC20NewUpdatedGasLimit, error) { + event := new(ZRC20NewUpdatedGasLimit) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedGasLimit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewUpdatedProtocolFlatFeeIterator is returned from FilterUpdatedProtocolFlatFee and is used to iterate over the raw logs and unpacked data for UpdatedProtocolFlatFee events raised by the ZRC20New contract. +type ZRC20NewUpdatedProtocolFlatFeeIterator struct { + Event *ZRC20NewUpdatedProtocolFlatFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewUpdatedProtocolFlatFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedProtocolFlatFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedProtocolFlatFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewUpdatedProtocolFlatFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewUpdatedProtocolFlatFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewUpdatedProtocolFlatFee represents a UpdatedProtocolFlatFee event raised by the ZRC20New contract. +type ZRC20NewUpdatedProtocolFlatFee struct { + ProtocolFlatFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedProtocolFlatFee is a free log retrieval operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) FilterUpdatedProtocolFlatFee(opts *bind.FilterOpts) (*ZRC20NewUpdatedProtocolFlatFeeIterator, error) { + + logs, sub, err := _ZRC20New.contract.FilterLogs(opts, "UpdatedProtocolFlatFee") + if err != nil { + return nil, err + } + return &ZRC20NewUpdatedProtocolFlatFeeIterator{contract: _ZRC20New.contract, event: "UpdatedProtocolFlatFee", logs: logs, sub: sub}, nil +} + +// WatchUpdatedProtocolFlatFee is a free log subscription operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) WatchUpdatedProtocolFlatFee(opts *bind.WatchOpts, sink chan<- *ZRC20NewUpdatedProtocolFlatFee) (event.Subscription, error) { + + logs, sub, err := _ZRC20New.contract.WatchLogs(opts, "UpdatedProtocolFlatFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewUpdatedProtocolFlatFee) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedProtocolFlatFee", 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 +} + +// ParseUpdatedProtocolFlatFee is a log parse operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) ParseUpdatedProtocolFlatFee(log types.Log) (*ZRC20NewUpdatedProtocolFlatFee, error) { + event := new(ZRC20NewUpdatedProtocolFlatFee) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedProtocolFlatFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewUpdatedSystemContractIterator is returned from FilterUpdatedSystemContract and is used to iterate over the raw logs and unpacked data for UpdatedSystemContract events raised by the ZRC20New contract. +type ZRC20NewUpdatedSystemContractIterator struct { + Event *ZRC20NewUpdatedSystemContract // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewUpdatedSystemContractIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedSystemContract) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewUpdatedSystemContract) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewUpdatedSystemContractIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewUpdatedSystemContractIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewUpdatedSystemContract represents a UpdatedSystemContract event raised by the ZRC20New contract. +type ZRC20NewUpdatedSystemContract struct { + SystemContract common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedSystemContract is a free log retrieval operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20New *ZRC20NewFilterer) FilterUpdatedSystemContract(opts *bind.FilterOpts) (*ZRC20NewUpdatedSystemContractIterator, error) { + + logs, sub, err := _ZRC20New.contract.FilterLogs(opts, "UpdatedSystemContract") + if err != nil { + return nil, err + } + return &ZRC20NewUpdatedSystemContractIterator{contract: _ZRC20New.contract, event: "UpdatedSystemContract", logs: logs, sub: sub}, nil +} + +// WatchUpdatedSystemContract is a free log subscription operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20New *ZRC20NewFilterer) WatchUpdatedSystemContract(opts *bind.WatchOpts, sink chan<- *ZRC20NewUpdatedSystemContract) (event.Subscription, error) { + + logs, sub, err := _ZRC20New.contract.WatchLogs(opts, "UpdatedSystemContract") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewUpdatedSystemContract) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedSystemContract", 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 +} + +// ParseUpdatedSystemContract is a log parse operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20New *ZRC20NewFilterer) ParseUpdatedSystemContract(log types.Log) (*ZRC20NewUpdatedSystemContract, error) { + event := new(ZRC20NewUpdatedSystemContract) + if err := _ZRC20New.contract.UnpackLog(event, "UpdatedSystemContract", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20NewWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the ZRC20New contract. +type ZRC20NewWithdrawalIterator struct { + Event *ZRC20NewWithdrawal // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20NewWithdrawalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20NewWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20NewWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20NewWithdrawalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20NewWithdrawalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20NewWithdrawal represents a Withdrawal event raised by the ZRC20New contract. +type ZRC20NewWithdrawal struct { + From common.Address + To []byte + Value *big.Int + Gasfee *big.Int + ProtocolFlatFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*ZRC20NewWithdrawalIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _ZRC20New.contract.FilterLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return &ZRC20NewWithdrawalIterator{contract: _ZRC20New.contract, event: "Withdrawal", logs: logs, sub: sub}, nil +} + +// WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ZRC20NewWithdrawal, from []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _ZRC20New.contract.WatchLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20NewWithdrawal) + if err := _ZRC20New.contract.UnpackLog(event, "Withdrawal", 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 +} + +// ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +func (_ZRC20New *ZRC20NewFilterer) ParseWithdrawal(log types.Log) (*ZRC20NewWithdrawal, error) { + event := new(ZRC20NewWithdrawal) + if err := _ZRC20New.contract.UnpackLog(event, "Withdrawal", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/hardhat/console.sol/console.go b/pkg/hardhat/console.sol/console.go deleted file mode 100644 index 9329d210..00000000 --- a/pkg/hardhat/console.sol/console.go +++ /dev/null @@ -1,203 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package console - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ConsoleMetaData contains all meta data concerning the Console contract. -var ConsoleMetaData = &bind.MetaData{ - ABI: "[]", - Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b984f068e9b45c3f00be7595f7bc61c482d2370eb5a8fa63bd27501c6f9a6d9264736f6c63430008070033", -} - -// ConsoleABI is the input ABI used to generate the binding from. -// Deprecated: Use ConsoleMetaData.ABI instead. -var ConsoleABI = ConsoleMetaData.ABI - -// ConsoleBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ConsoleMetaData.Bin instead. -var ConsoleBin = ConsoleMetaData.Bin - -// DeployConsole deploys a new Ethereum contract, binding an instance of Console to it. -func DeployConsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Console, error) { - parsed, err := ConsoleMetaData.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(ConsoleBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil -} - -// Console is an auto generated Go binding around an Ethereum contract. -type Console struct { - ConsoleCaller // Read-only binding to the contract - ConsoleTransactor // Write-only binding to the contract - ConsoleFilterer // Log filterer for contract events -} - -// ConsoleCaller is an auto generated read-only Go binding around an Ethereum contract. -type ConsoleCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConsoleTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ConsoleTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ConsoleFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ConsoleSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ConsoleSession struct { - Contract *Console // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ConsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ConsoleCallerSession struct { - Contract *ConsoleCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ConsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ConsoleTransactorSession struct { - Contract *ConsoleTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ConsoleRaw is an auto generated low-level Go binding around an Ethereum contract. -type ConsoleRaw struct { - Contract *Console // Generic contract binding to access the raw methods on -} - -// ConsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ConsoleCallerRaw struct { - Contract *ConsoleCaller // Generic read-only contract binding to access the raw methods on -} - -// ConsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ConsoleTransactorRaw struct { - Contract *ConsoleTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewConsole creates a new instance of Console, bound to a specific deployed contract. -func NewConsole(address common.Address, backend bind.ContractBackend) (*Console, error) { - contract, err := bindConsole(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil -} - -// NewConsoleCaller creates a new read-only instance of Console, bound to a specific deployed contract. -func NewConsoleCaller(address common.Address, caller bind.ContractCaller) (*ConsoleCaller, error) { - contract, err := bindConsole(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ConsoleCaller{contract: contract}, nil -} - -// NewConsoleTransactor creates a new write-only instance of Console, bound to a specific deployed contract. -func NewConsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*ConsoleTransactor, error) { - contract, err := bindConsole(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ConsoleTransactor{contract: contract}, nil -} - -// NewConsoleFilterer creates a new log filterer instance of Console, bound to a specific deployed contract. -func NewConsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*ConsoleFilterer, error) { - contract, err := bindConsole(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ConsoleFilterer{contract: contract}, nil -} - -// bindConsole binds a generic wrapper to an already deployed contract. -func bindConsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ConsoleMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Console *ConsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Console.Contract.ConsoleCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Console *ConsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Console.Contract.ConsoleTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Console *ConsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Console.Contract.ConsoleTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Console *ConsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Console.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Console *ConsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Console.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Console *ConsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Console.Contract.contract.Transact(opts, method, params...) -} diff --git a/test/prototypes/GatewayZEVM.spec.ts b/test/prototypes/GatewayZEVM.spec.ts index 92b35275..f215e762 100644 --- a/test/prototypes/GatewayZEVM.spec.ts +++ b/test/prototypes/GatewayZEVM.spec.ts @@ -9,11 +9,13 @@ import { ethers, upgrades } from "hardhat"; import { FUNGIBLE_MODULE_ADDRESS } from "../test.helpers"; const hre = require("hardhat"); -describe("GatewayZEVM inbound", function () { +describe("GatewayZEVM", function () { let ZRC20Contract: ZRC20; let systemContract: SystemContract; let gateway: Contract; + let testZContract: Contract; let owner: SignerWithAddress; + let fungibleModuleSigner: SignerWithAddress; let addrs: SignerWithAddress[]; beforeEach(async () => { @@ -26,13 +28,19 @@ describe("GatewayZEVM inbound", function () { }); // Get a signer for the fungible module account - const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); + fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; - const ZRC20Factory = await ethers.getContractFactory("ZRC20"); + const Gateway = await ethers.getContractFactory("GatewayZEVM"); + gateway = await upgrades.deployProxy(Gateway, [], { + initializer: "initialize", + kind: "uups", + }); + + const ZRC20Factory = await ethers.getContractFactory("ZRC20New"); ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( "TOKEN", "TKN", @@ -40,7 +48,8 @@ describe("GatewayZEVM inbound", function () { 1, 1, 0, - systemContract.address + systemContract.address, + gateway.address )) as ZRC20; await systemContract.setGasCoinZRC20(1, ZRC20Contract.address); @@ -48,67 +57,130 @@ describe("GatewayZEVM inbound", function () { await ZRC20Contract.connect(fungibleModuleSigner).deposit(owner.address, parseEther("100")); - const Gateway = await ethers.getContractFactory("GatewayZEVM"); - gateway = await upgrades.deployProxy(Gateway, [], { - initializer: "initialize", - kind: "uups", - }); - await ZRC20Contract.connect(owner).approve(gateway.address, parseEther("100")); - }); - it("should withdraw zrc20 and emit event", async function () { - const tx = await gateway - .connect(owner) - .withdraw(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); - - const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; - expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); - - await expect(tx) - .to.emit(gateway, "Withdrawal") - .withArgs( - ethers.utils.getAddress(owner.address), - addrs[0].address.toLowerCase(), - parseEther("1"), - 0, - await ZRC20Contract.PROTOCOL_FLAT_FEE(), - "0x" - ); + const TestZContract = await ethers.getContractFactory("TestZContract"); + testZContract = await TestZContract.deploy(); }); - it("should withdraw zrc20 and call and emit event with message", async function () { - let ABI = ["function hello(address to)"]; - let iface = new ethers.utils.Interface(ABI); - const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); - - const tx = await gateway - .connect(owner) - .withdrawAndCall(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); - - const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; - expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); - - await expect(tx) - .to.emit(gateway, "Withdrawal") - .withArgs( - ethers.utils.getAddress(owner.address), - addrs[0].address.toLowerCase(), - parseEther("1"), - 0, - await ZRC20Contract.PROTOCOL_FLAT_FEE(), - message - ); + describe("GatewayZEVM inbound", function () { + it("should withdraw zrc20 and emit event", async function () { + const tx = await gateway + .connect(owner) + .withdraw(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); + + const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + + await expect(tx) + .to.emit(gateway, "Withdrawal") + .withArgs( + ethers.utils.getAddress(owner.address), + addrs[0].address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + "0x" + ); + }); + + it("should withdraw zrc20 and call and emit event with message", async function () { + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tx = await gateway + .connect(owner) + .withdrawAndCall(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); + + const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; + expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); + + await expect(tx) + .to.emit(gateway, "Withdrawal") + .withArgs( + ethers.utils.getAddress(owner.address), + addrs[0].address.toLowerCase(), + parseEther("1"), + 0, + await ZRC20Contract.PROTOCOL_FLAT_FEE(), + message + ); + }); + + it("should call and emit event without asset transfer", async function () { + let ABI = ["function hello(address to)"]; + let iface = new ethers.utils.Interface(ABI); + const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + + const tx = await gateway.connect(owner).call(ethers.utils.arrayify(addrs[0].address), message); + await expect(tx) + .to.emit(gateway, "Call") + .withArgs(ethers.utils.getAddress(owner.address), addrs[0].address.toLowerCase(), message); + }); }); - it("should call and emit event without asset transfer", async function () { - let ABI = ["function hello(address to)"]; - let iface = new ethers.utils.Interface(ABI); - const message = iface.encodeFunctionData("hello", ["0x1234567890123456789012345678901234567890"]); + describe("GatewayZEVM outbound", function () { + it("should deposit", async function () { + const balanceBeforeDeposit = (await ZRC20Contract.balanceOf(addrs[0].address)) as BigNumber; + expect(balanceBeforeDeposit).to.equal(parseEther("0")); - const tx = await gateway.connect(owner).call(ethers.utils.arrayify(addrs[0].address), message); - await expect(tx) - .to.emit(gateway, "Call") - .withArgs(ethers.utils.getAddress(owner.address), addrs[0].address.toLowerCase(), message); + await gateway.connect(fungibleModuleSigner).deposit(ZRC20Contract.address, parseEther("1"), addrs[0].address); + + const balanceAfterDeposit = (await ZRC20Contract.balanceOf(addrs[0].address)) as BigNumber; + expect(balanceAfterDeposit).to.equal(parseEther("1")); + }); + + it("execute zContract", async function () { + const message = ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); + const tx = await gateway + .connect(fungibleModuleSigner) + .execute( + [gateway.address, fungibleModuleSigner.address, 1], + ZRC20Contract.address, + parseEther("1"), + testZContract.address, + message + ); + + await expect(tx) + .to.emit(testZContract, "ContextData") + .withArgs( + gateway.address.toLowerCase(), + ethers.utils.getAddress(fungibleModuleSigner.address), + 1, + ethers.utils.getAddress(gateway.address), + "hello" + ); + }); + + it("should deposit and call zContract", async function () { + const balanceBeforeDeposit = (await ZRC20Contract.balanceOf(testZContract.address)) as BigNumber; + expect(balanceBeforeDeposit).to.equal(parseEther("0")); + + const message = ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); + const tx = await gateway + .connect(fungibleModuleSigner) + .depositAndCall( + [gateway.address, fungibleModuleSigner.address, 1], + ZRC20Contract.address, + parseEther("1"), + testZContract.address, + message + ); + + const balanceAfterDeposit = (await ZRC20Contract.balanceOf(testZContract.address)) as BigNumber; + expect(balanceAfterDeposit).to.equal(parseEther("1")); + + await expect(tx) + .to.emit(testZContract, "ContextData") + .withArgs( + gateway.address.toLowerCase(), + ethers.utils.getAddress(fungibleModuleSigner.address), + 1, + ethers.utils.getAddress(gateway.address), + "hello" + ); + }); }); }); diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts index 1b88a559..04d1fed5 100644 --- a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -28,10 +28,25 @@ import type { PromiseOrValue, } from "../../../common"; +export type ZContextStruct = { + origin: PromiseOrValue; + sender: PromiseOrValue; + chainID: PromiseOrValue; +}; + +export type ZContextStructOutput = [string, string, BigNumber] & { + origin: string; + sender: string; + chainID: BigNumber; +}; + export interface GatewayZEVMInterface extends utils.Interface { functions: { "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; "call(bytes,bytes)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; + "execute((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; "initialize()": FunctionFragment; "owner()": FunctionFragment; "proxiableUUID()": FunctionFragment; @@ -47,6 +62,9 @@ export interface GatewayZEVMInterface extends utils.Interface { nameOrSignatureOrTopic: | "FUNGIBLE_MODULE_ADDRESS" | "call" + | "deposit" + | "depositAndCall" + | "execute" | "initialize" | "owner" | "proxiableUUID" @@ -66,6 +84,34 @@ export interface GatewayZEVMInterface extends utils.Interface { functionFragment: "call", values: [PromiseOrValue, PromiseOrValue] ): string; + encodeFunctionData( + functionFragment: "deposit", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "execute", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; encodeFunctionData( functionFragment: "initialize", values?: undefined @@ -114,6 +160,12 @@ export interface GatewayZEVMInterface extends utils.Interface { data: BytesLike ): Result; decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "depositAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; decodeFunctionResult( @@ -264,6 +316,31 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + initialize( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -316,6 +393,31 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + initialize( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -368,6 +470,31 @@ export interface GatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + initialize(overrides?: CallOverrides): Promise; owner(overrides?: CallOverrides): Promise; @@ -482,6 +609,31 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + initialize( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -537,6 +689,31 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + initialize( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; diff --git a/typechain-types/contracts/prototypes/zevm/TestZContract.ts b/typechain-types/contracts/prototypes/zevm/TestZContract.ts new file mode 100644 index 00000000..609bab74 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/TestZContract.ts @@ -0,0 +1,175 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export type ZContextStruct = { + origin: PromiseOrValue; + sender: PromiseOrValue; + chainID: PromiseOrValue; +}; + +export type ZContextStructOutput = [string, string, BigNumber] & { + origin: string; + sender: string; + chainID: BigNumber; +}; + +export interface TestZContractInterface extends utils.Interface { + functions: { + "onCrossChainCall((bytes,address,uint256),address,uint256,bytes)": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "onCrossChainCall"): FunctionFragment; + + encodeFunctionData( + functionFragment: "onCrossChainCall", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "onCrossChainCall", + data: BytesLike + ): Result; + + events: { + "ContextData(bytes,address,uint256,address,string)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ContextData"): EventFragment; +} + +export interface ContextDataEventObject { + origin: string; + sender: string; + chainID: BigNumber; + msgSender: string; + message: string; +} +export type ContextDataEvent = TypedEvent< + [string, string, BigNumber, string, string], + ContextDataEventObject +>; + +export type ContextDataEventFilter = TypedEventFilter; + +export interface TestZContract extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: TestZContractInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + onCrossChainCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + onCrossChainCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + onCrossChainCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "ContextData(bytes,address,uint256,address,string)"( + origin?: null, + sender?: null, + chainID?: null, + msgSender?: null, + message?: null + ): ContextDataEventFilter; + ContextData( + origin?: null, + sender?: null, + chainID?: null, + msgSender?: null, + message?: null + ): ContextDataEventFilter; + }; + + estimateGas: { + onCrossChainCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + onCrossChainCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors.ts b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors.ts new file mode 100644 index 00000000..097645d4 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface ZRC20ErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface ZRC20Errors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZRC20ErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New.ts b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New.ts new file mode 100644 index 00000000..7acc65b2 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New.ts @@ -0,0 +1,854 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface ZRC20NewInterface extends utils.Interface { + functions: { + "CHAIN_ID()": FunctionFragment; + "COIN_TYPE()": FunctionFragment; + "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; + "GAS_LIMIT()": FunctionFragment; + "GATEWAY_CONTRACT_ADDRESS()": FunctionFragment; + "PROTOCOL_FLAT_FEE()": FunctionFragment; + "SYSTEM_CONTRACT_ADDRESS()": FunctionFragment; + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "burn(uint256)": FunctionFragment; + "decimals()": FunctionFragment; + "deposit(address,uint256)": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + "updateGasLimit(uint256)": FunctionFragment; + "updateProtocolFlatFee(uint256)": FunctionFragment; + "updateSystemContractAddress(address)": FunctionFragment; + "withdraw(bytes,uint256)": FunctionFragment; + "withdrawGasFee()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "CHAIN_ID" + | "COIN_TYPE" + | "FUNGIBLE_MODULE_ADDRESS" + | "GAS_LIMIT" + | "GATEWAY_CONTRACT_ADDRESS" + | "PROTOCOL_FLAT_FEE" + | "SYSTEM_CONTRACT_ADDRESS" + | "allowance" + | "approve" + | "balanceOf" + | "burn" + | "decimals" + | "deposit" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + | "updateGasLimit" + | "updateProtocolFlatFee" + | "updateSystemContractAddress" + | "withdraw" + | "withdrawGasFee" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "CHAIN_ID", values?: undefined): string; + encodeFunctionData(functionFragment: "COIN_TYPE", values?: undefined): string; + encodeFunctionData( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "GAS_LIMIT", values?: undefined): string; + encodeFunctionData( + functionFragment: "GATEWAY_CONTRACT_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "PROTOCOL_FLAT_FEE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "SYSTEM_CONTRACT_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "burn", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "updateGasLimit", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "updateProtocolFlatFee", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "updateSystemContractAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawGasFee", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "CHAIN_ID", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "COIN_TYPE", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "GAS_LIMIT", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "GATEWAY_CONTRACT_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "PROTOCOL_FLAT_FEE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "SYSTEM_CONTRACT_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateGasLimit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateProtocolFlatFee", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateSystemContractAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawGasFee", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Deposit(bytes,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + "UpdatedGasLimit(uint256)": EventFragment; + "UpdatedProtocolFlatFee(uint256)": EventFragment; + "UpdatedSystemContract(address)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedGasLimit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedProtocolFlatFee"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedSystemContract"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface DepositEventObject { + from: string; + to: string; + value: BigNumber; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface UpdatedGasLimitEventObject { + gasLimit: BigNumber; +} +export type UpdatedGasLimitEvent = TypedEvent< + [BigNumber], + UpdatedGasLimitEventObject +>; + +export type UpdatedGasLimitEventFilter = TypedEventFilter; + +export interface UpdatedProtocolFlatFeeEventObject { + protocolFlatFee: BigNumber; +} +export type UpdatedProtocolFlatFeeEvent = TypedEvent< + [BigNumber], + UpdatedProtocolFlatFeeEventObject +>; + +export type UpdatedProtocolFlatFeeEventFilter = + TypedEventFilter; + +export interface UpdatedSystemContractEventObject { + systemContract: string; +} +export type UpdatedSystemContractEvent = TypedEvent< + [string], + UpdatedSystemContractEventObject +>; + +export type UpdatedSystemContractEventFilter = + TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface ZRC20New extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZRC20NewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + CHAIN_ID(overrides?: CallOverrides): Promise<[BigNumber]>; + + COIN_TYPE(overrides?: CallOverrides): Promise<[number]>; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + GAS_LIMIT(overrides?: CallOverrides): Promise<[BigNumber]>; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + + callStatic: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Deposit(bytes,address,uint256)"( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + Deposit( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + + "UpdatedGasLimit(uint256)"(gasLimit?: null): UpdatedGasLimitEventFilter; + UpdatedGasLimit(gasLimit?: null): UpdatedGasLimitEventFilter; + + "UpdatedProtocolFlatFee(uint256)"( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + UpdatedProtocolFlatFee( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + + "UpdatedSystemContract(address)"( + systemContract?: null + ): UpdatedSystemContractEventFilter; + UpdatedSystemContract( + systemContract?: null + ): UpdatedSystemContractEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + }; + + estimateGas: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS( + overrides?: CallOverrides + ): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS( + overrides?: CallOverrides + ): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS( + overrides?: CallOverrides + ): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/index.ts b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/index.ts new file mode 100644 index 00000000..ea6138df --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/ZRC20New.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { ZRC20Errors } from "./ZRC20Errors"; +export type { ZRC20New } from "./ZRC20New"; diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts index ae132f5b..0bf18c3c 100644 --- a/typechain-types/contracts/prototypes/zevm/index.ts +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -1,7 +1,10 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +import type * as zrc20NewSol from "./ZRC20New.sol"; +export type { zrc20NewSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { GatewayZEVM } from "./GatewayZEVM"; export type { Sender } from "./Sender"; +export type { TestZContract } from "./TestZContract"; diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts index c4041432..12f1fa68 100644 --- a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM.ts @@ -23,21 +23,70 @@ import type { PromiseOrValue, } from "../../../../common"; +export type ZContextStruct = { + origin: PromiseOrValue; + sender: PromiseOrValue; + chainID: PromiseOrValue; +}; + +export type ZContextStructOutput = [string, string, BigNumber] & { + origin: string; + sender: string; + chainID: BigNumber; +}; + export interface IGatewayZEVMInterface extends utils.Interface { functions: { "call(bytes,bytes)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; + "execute((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; "withdraw(bytes,uint256,address)": FunctionFragment; "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: "call" | "withdraw" | "withdrawAndCall" + nameOrSignatureOrTopic: + | "call" + | "deposit" + | "depositAndCall" + | "execute" + | "withdraw" + | "withdrawAndCall" ): FunctionFragment; encodeFunctionData( functionFragment: "call", values: [PromiseOrValue, PromiseOrValue] ): string; + encodeFunctionData( + functionFragment: "deposit", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "execute", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; encodeFunctionData( functionFragment: "withdraw", values: [ @@ -57,6 +106,12 @@ export interface IGatewayZEVMInterface extends utils.Interface { ): string; decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "depositAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; decodeFunctionResult( functionFragment: "withdrawAndCall", @@ -99,6 +154,31 @@ export interface IGatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + withdraw( receiver: PromiseOrValue, amount: PromiseOrValue, @@ -121,6 +201,31 @@ export interface IGatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + withdraw( receiver: PromiseOrValue, amount: PromiseOrValue, @@ -143,6 +248,31 @@ export interface IGatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + withdraw( receiver: PromiseOrValue, amount: PromiseOrValue, @@ -168,6 +298,31 @@ export interface IGatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + withdraw( receiver: PromiseOrValue, amount: PromiseOrValue, @@ -191,6 +346,31 @@ export interface IGatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + withdraw( receiver: PromiseOrValue, amount: PromiseOrValue, diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index 5a5efbed..041c238f 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -15,6 +15,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, { inputs: [], name: "GasFeeTransferFailed", @@ -25,6 +30,11 @@ const _abi = [ name: "InsufficientZRC20Amount", type: "error", }, + { + inputs: [], + name: "InvalidTarget", + type: "error", + }, { inputs: [], name: "WithdrawalFailed", @@ -206,6 +216,129 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "execute", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [], name: "initialize", @@ -344,7 +477,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts index 603503d6..65a4efd0 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts @@ -103,7 +103,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/TestZContract__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/TestZContract__factory.ts new file mode 100644 index 00000000..d7849ee2 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/TestZContract__factory.ts @@ -0,0 +1,145 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + TestZContract, + TestZContractInterface, +} from "../../../../contracts/prototypes/zevm/TestZContract"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "msgSender", + type: "address", + }, + { + indexed: false, + internalType: "string", + name: "message", + type: "string", + }, + ], + name: "ContextData", + type: "event", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "onCrossChainCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type TestZContractConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: TestZContractConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class TestZContract__factory extends ContractFactory { + constructor(...args: TestZContractConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): TestZContract { + return super.attach(address) as TestZContract; + } + override connect(signer: Signer): TestZContract__factory { + return super.connect(signer) as TestZContract__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): TestZContractInterface { + return new utils.Interface(_abi) as TestZContractInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): TestZContract { + return new Contract(address, _abi, signerOrProvider) as TestZContract; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory.ts new file mode 100644 index 00000000..299c388e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory.ts @@ -0,0 +1,66 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ZRC20Errors, + ZRC20ErrorsInterface, +} from "../../../../../contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors"; + +const _abi = [ + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InvalidSender", + type: "error", + }, + { + inputs: [], + name: "LowAllowance", + type: "error", + }, + { + inputs: [], + name: "LowBalance", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + inputs: [], + name: "ZeroGasCoin", + type: "error", + }, + { + inputs: [], + name: "ZeroGasPrice", + type: "error", + }, +] as const; + +export class ZRC20Errors__factory { + static readonly abi = _abi; + static createInterface(): ZRC20ErrorsInterface { + return new utils.Interface(_abi) as ZRC20ErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZRC20Errors { + return new Contract(address, _abi, signerOrProvider) as ZRC20Errors; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory.ts new file mode 100644 index 00000000..1f4d67bc --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory.ts @@ -0,0 +1,730 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../../common"; +import type { + ZRC20New, + ZRC20NewInterface, +} from "../../../../../contracts/prototypes/zevm/ZRC20New.sol/ZRC20New"; + +const _abi = [ + { + inputs: [ + { + internalType: "string", + name: "name_", + type: "string", + }, + { + internalType: "string", + name: "symbol_", + type: "string", + }, + { + internalType: "uint8", + name: "decimals_", + type: "uint8", + }, + { + internalType: "uint256", + name: "chainid_", + type: "uint256", + }, + { + internalType: "enum CoinType", + name: "coinType_", + type: "uint8", + }, + { + internalType: "uint256", + name: "gasLimit_", + type: "uint256", + }, + { + internalType: "address", + name: "systemContractAddress_", + type: "address", + }, + { + internalType: "address", + name: "gatewayContractAddress_", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InvalidSender", + type: "error", + }, + { + inputs: [], + name: "LowAllowance", + type: "error", + }, + { + inputs: [], + name: "LowBalance", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + inputs: [], + name: "ZeroGasCoin", + type: "error", + }, + { + inputs: [], + name: "ZeroGasPrice", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "from", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "gasLimit", + type: "uint256", + }, + ], + name: "UpdatedGasLimit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "UpdatedProtocolFlatFee", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "systemContract", + type: "address", + }, + ], + name: "UpdatedSystemContract", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + inputs: [], + name: "CHAIN_ID", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "COIN_TYPE", + outputs: [ + { + internalType: "enum CoinType", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "FUNGIBLE_MODULE_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "GAS_LIMIT", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "GATEWAY_CONTRACT_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PROTOCOL_FLAT_FEE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "SYSTEM_CONTRACT_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burn", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "deposit", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "gasLimit", + type: "uint256", + }, + ], + name: "updateGasLimit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "updateProtocolFlatFee", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + ], + name: "updateSystemContractAddress", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "withdrawGasFee", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZRC20NewConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZRC20NewConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZRC20New__factory extends ContractFactory { + constructor(...args: ZRC20NewConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + chainid_: PromiseOrValue, + coinType_: PromiseOrValue, + gasLimit_: PromiseOrValue, + systemContractAddress_: PromiseOrValue, + gatewayContractAddress_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + name_, + symbol_, + decimals_, + chainid_, + coinType_, + gasLimit_, + systemContractAddress_, + gatewayContractAddress_, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + chainid_: PromiseOrValue, + coinType_: PromiseOrValue, + gasLimit_: PromiseOrValue, + systemContractAddress_: PromiseOrValue, + gatewayContractAddress_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction( + name_, + symbol_, + decimals_, + chainid_, + coinType_, + gasLimit_, + systemContractAddress_, + gatewayContractAddress_, + overrides || {} + ); + } + override attach(address: string): ZRC20New { + return super.attach(address) as ZRC20New; + } + override connect(signer: Signer): ZRC20New__factory { + return super.connect(signer) as ZRC20New__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZRC20NewInterface { + return new utils.Interface(_abi) as ZRC20NewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZRC20New { + return new Contract(address, _abi, signerOrProvider) as ZRC20New; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/index.ts b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/index.ts new file mode 100644 index 00000000..7e4b987c --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/ZRC20New.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { ZRC20Errors__factory } from "./ZRC20Errors__factory"; +export { ZRC20New__factory } from "./ZRC20New__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts index d04ef17c..54162241 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -1,6 +1,8 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +export * as zrc20NewSol from "./ZRC20New.sol"; export * as interfacesSol from "./interfaces.sol"; export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; export { Sender__factory } from "./Sender__factory"; +export { TestZContract__factory } from "./TestZContract__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts index 7d6206b4..aef304ee 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory.ts @@ -28,6 +28,129 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "execute", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index cb333a18..e7b1e088 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -368,6 +368,18 @@ declare module "hardhat/types/runtime" { name: "Sender", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "TestZContract", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ZRC20Errors", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ZRC20New", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions @@ -882,6 +894,21 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "TestZContract", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZRC20Errors", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZRC20New", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ISystem", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 63942633..a2eabf95 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -174,6 +174,12 @@ export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IG export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; export type { Sender } from "./contracts/prototypes/zevm/Sender"; export { Sender__factory } from "./factories/contracts/prototypes/zevm/Sender__factory"; +export type { TestZContract } from "./contracts/prototypes/zevm/TestZContract"; +export { TestZContract__factory } from "./factories/contracts/prototypes/zevm/TestZContract__factory"; +export type { ZRC20Errors } from "./contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors"; +export { ZRC20Errors__factory } from "./factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory"; +export type { ZRC20New } from "./contracts/prototypes/zevm/ZRC20New.sol/ZRC20New"; +export { ZRC20New__factory } from "./factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory"; export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; @@ -194,5 +200,3 @@ export type { ZetaConnectorZEVM } from "./contracts/zevm/ZetaConnectorZEVM.sol/Z export { ZetaConnectorZEVM__factory } from "./factories/contracts/zevm/ZetaConnectorZEVM.sol/ZetaConnectorZEVM__factory"; export type { ZRC20 } from "./contracts/zevm/ZRC20.sol/ZRC20"; export { ZRC20__factory } from "./factories/contracts/zevm/ZRC20.sol/ZRC20__factory"; -export type { ZRC20Errors } from "./contracts/zevm/ZRC20.sol/ZRC20Errors"; -export { ZRC20Errors__factory } from "./factories/contracts/zevm/ZRC20.sol/ZRC20Errors__factory"; From a09cc0c057ddee0b83b1b3893ece9789dd0137f1 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 1 Jul 2024 23:08:05 +0200 Subject: [PATCH 23/86] start worker script to deploy evm and zevm contracts on local hardhat node --- package.json | 4 +- scripts/worker.ts | 127 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 130 insertions(+), 1 deletion(-) create mode 100644 scripts/worker.ts diff --git a/package.json b/package.json index 54c9ada9..3a8a8f78 100644 --- a/package.json +++ b/package.json @@ -85,7 +85,9 @@ "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", - "tsc:watch": "npx tsc --watch" + "tsc:watch": "npx tsc --watch", + "localnode": "npx hardhat node", + "localnet": "npx hardhat run scripts/worker.ts --network localhost" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/scripts/worker.ts b/scripts/worker.ts new file mode 100644 index 00000000..5d8971d3 --- /dev/null +++ b/scripts/worker.ts @@ -0,0 +1,127 @@ +import { AddressZero } from "@ethersproject/constants"; +import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; +import { SystemContract, ZRC20 } from "@typechain-types"; +import { expect } from "chai"; +import { Contract } from "ethers"; +import { parseEther } from "ethers/lib/utils"; +import { ethers, upgrades } from "hardhat"; + +const hre = require("hardhat"); + +export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; + +export const startLocalnet = async () => { + console.log('deploying contracts') + // EVM + let receiverEVM: Contract; + let gatewayEVM: Contract; + let token: Contract; + let custody: Contract; + let ownerEVM: any, destination: any, tssAddress: any; + + // ZEVM + let senderZEVM: Contract; + let ZRC20Contract: ZRC20; + let systemContract: SystemContract; + let gatewayZEVM: Contract; + let ownerZEVM: SignerWithAddress; + let addrs: SignerWithAddress[]; + + [ownerEVM, ownerZEVM, destination, tssAddress, ...addrs] = await ethers.getSigners(); + // Prepare EVM + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const ReceiverEVM = await ethers.getContractFactory("Receiver"); + const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); + const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + + // Deploy the contracts + token = await TestERC20.deploy("Test Token", "TTK"); + console.log("EVM: ERC20(TTK) token deployed to:", token.address); + + receiverEVM = await ReceiverEVM.deploy(); + console.log("EVM: Receiver deployed to:", receiverEVM.address); + + gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tssAddress.address], { + initializer: "initialize", + kind: "uups", + }); + console.log("EVM: GatewayEVM deployed to:", gatewayEVM.address); + + custody = await Custody.deploy(gatewayEVM.address); + gatewayEVM.setCustody(custody.address); + console.log("EVM: ERC20Custody deployed to:", custody.address); + + // Mint initial supply to the owner + await token.mint(ownerEVM.address, ethers.utils.parseEther("1000")); + console.log("EVM: 1000TTK minted to:", ownerEVM.address); + + // Transfer some tokens to the custody contract + await token.transfer(custody.address, ethers.utils.parseEther("500")); + console.log("EVM: 500TTK transfered to custody from:", ownerEVM.address); + + // Prepare ZEVM + // Impersonate the fungible module account + await hre.network.provider.request({ + method: "hardhat_impersonateAccount", + params: [FUNGIBLE_MODULE_ADDRESS], + }); + + // Get a signer for the fungible module account + const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); + hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); + + const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); + systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; + console.log("ZEVM: SystemContract deployed to:", systemContract.address); + + const GatewayZEVM = await ethers.getContractFactory("GatewayZEVM"); + gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [], { + initializer: "initialize", + kind: "uups", + }); + console.log("ZEVM: GatewayZEVM deployed to:", gatewayZEVM.address); + + const ZRC20Factory = await ethers.getContractFactory("ZRC20New"); + ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( + "TOKEN", + "TKN", + 18, + 1, + 1, + 0, + systemContract.address, + gatewayZEVM.address, + )) as ZRC20; + console.log("ZEVM: ZRC20(TKN) contract deployed to:", ZRC20Contract.address); + + await systemContract.setGasCoinZRC20(1, ZRC20Contract.address); + await systemContract.setGasPrice(1, ZRC20Contract.address); + + await ZRC20Contract.connect(fungibleModuleSigner).deposit(ownerZEVM.address, parseEther("100")); + console.log("ZEVM: Fungible module deposited 100TKN to:", ownerZEVM.address); + + await ZRC20Contract.connect(ownerZEVM).approve(gatewayZEVM.address, parseEther("100")); + console.log(`ZEVM: ${ownerZEVM.address} approved GatewayZEVM ${gatewayZEVM.address} 100TKN`); + + // including abi of gatewayZEVM events, so hardhat can decode them automatically + const senderArtifact = await hre.artifacts.readArtifact("Sender"); + const gatewayZEVMArtifact = await hre.artifacts.readArtifact("GatewayZEVM"); + const senderABI = [ + ...senderArtifact.abi, + ...gatewayZEVMArtifact.abi.filter((f: ethers.utils.Fragment) => f.type === "event"), + ]; + + const SenderZEVM = new ethers.ContractFactory(senderABI, senderArtifact.bytecode, ownerZEVM); + senderZEVM = await SenderZEVM.deploy(gatewayZEVM.address); + console.log("ZEVM: Sender contract deployed to:", senderZEVM.address); + + await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); + console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); +} + +startLocalnet() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error); + process.exit(1); + }); \ No newline at end of file From b39bc57ee9577733ed17c764e1e2e094155e8747 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 1 Jul 2024 23:44:54 +0200 Subject: [PATCH 24/86] add simple script to deposit to gateway evm and listen to event in worker --- scripts/gatewayEVMdeposit.ts | 20 ++++++++++++++++++++ scripts/worker.ts | 13 ++++++++++--- 2 files changed, 30 insertions(+), 3 deletions(-) create mode 100644 scripts/gatewayEVMdeposit.ts diff --git a/scripts/gatewayEVMdeposit.ts b/scripts/gatewayEVMdeposit.ts new file mode 100644 index 00000000..a6aa260e --- /dev/null +++ b/scripts/gatewayEVMdeposit.ts @@ -0,0 +1,20 @@ +import { ethers } from "hardhat"; + +const hre = require("hardhat"); + +async function main() { + const gatewayEVMAddress = "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309"; + const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", gatewayEVMAddress); + let [, , destination] = await ethers.getSigners(); + + const deposit = await gatewayEVM["deposit(address)"](destination.address, { value: ethers.utils.parseEther("1") }); + + console.log("deposit hash:", deposit.hash); +} + +main() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error); + process.exit(1); + }); \ No newline at end of file diff --git a/scripts/worker.ts b/scripts/worker.ts index 5d8971d3..552a0b4f 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -1,7 +1,6 @@ import { AddressZero } from "@ethersproject/constants"; import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; import { SystemContract, ZRC20 } from "@typechain-types"; -import { expect } from "chai"; import { Contract } from "ethers"; import { parseEther } from "ethers/lib/utils"; import { ethers, upgrades } from "hardhat"; @@ -117,11 +116,19 @@ export const startLocalnet = async () => { await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); + + gatewayEVM.on("Deposit", (...args: Array) => { + console.log("EVM: GatewayEVM Deposit event:", args) + }) + + process.stdin.resume(); } startLocalnet() - .then(() => process.exit(0)) + .then(() => { + console.log('Setup complete, monitoring events. Press CTRL+C to exit.'); + }) .catch((error) => { - console.error(error); + console.error('Failed to deploy contracts or set up listeners:', error); process.exit(1); }); \ No newline at end of file From 7e3ad3e45aac5981d2bcc7f3a5b6b39b61a50825 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 12:28:42 +0200 Subject: [PATCH 25/86] fix coderabbit comments --- contracts/prototypes/evm/ERC20CustodyNew.sol | 12 ++++++++---- contracts/prototypes/evm/GatewayEVM.sol | 17 ++++++++++------- .../prototypes/evm/GatewayEVMUpgradeTest.sol | 14 +++++++++----- contracts/prototypes/evm/Receiver.sol | 5 ++++- contracts/prototypes/zevm/Sender.sol | 3 ++- .../prototypes/evm/ERC20CustodyNew__factory.ts | 2 +- .../evm/GatewayEVMUpgradeTest__factory.ts | 7 ++++++- .../prototypes/evm/GatewayEVM__factory.ts | 7 ++++++- .../prototypes/evm/Receiver__factory.ts | 2 +- .../prototypes/zevm/Sender__factory.ts | 7 ++++++- 10 files changed, 53 insertions(+), 23 deletions(-) diff --git a/contracts/prototypes/evm/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol index 2dbf54a4..2a4adbb4 100644 --- a/contracts/prototypes/evm/ERC20CustodyNew.sol +++ b/contracts/prototypes/evm/ERC20CustodyNew.sol @@ -3,11 +3,15 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./interfaces.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; // As the current version, ERC20CustodyNew hold the ERC20s deposited on ZetaChain // This version include a functionality allowing to call a contract // ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract -contract ERC20CustodyNew { +contract ERC20CustodyNew is ReentrancyGuard{ + using SafeERC20 for IERC20; + IGatewayEVM public gateway; event Withdraw(address indexed token, address indexed to, uint256 amount); @@ -18,15 +22,15 @@ contract ERC20CustodyNew { } // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call - function withdraw(address token, address to, uint256 amount) external { - IERC20(token).transfer(to, amount); + function withdraw(address token, address to, uint256 amount) external nonReentrant { + IERC20(token).safeTransfer(to, amount); emit Withdraw(token, to, amount); } // WithdrawAndCall is called by TSS address, it transfers the tokens and call a contract // For this, it passes through the Gateway contract, it transfers the tokens to the Gateway contract and then calls the contract - function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external { + function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external nonReentrant { // Transfer the tokens to the Gateway contract IERC20(token).transfer(address(gateway), amount); diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 43bf4046..171f7283 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -2,19 +2,22 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; - // The GatewayEVM contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { + using SafeERC20 for IERC20; + error ExecutionFailed(); error DepositFailed(); error InsufficientETHAmount(); error InsufficientERC20Amount(); error ZeroAddress(); + error ApprovalFailed(); address public custody; address public tssAddress; @@ -73,19 +76,19 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens - IERC20(token).approve(to, 0); - IERC20(token).approve(to, amount); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!IERC20(token).approve(to, amount)) revert ApprovalFailed(); // Execute the call on the target contract bytes memory result = _execute(to, data); // Reset approval - IERC20(token).approve(to, 0); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); // Transfer any remaining tokens back to the custody contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).transfer(address(custody), remainingBalance); + IERC20(token).safeTransfer(address(custody), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -108,7 +111,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { // Deposit ERC20 tokens to custody function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).transferFrom(msg.sender, address(custody), amount); + IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); emit Deposit(msg.sender, receiver, amount, asset, ""); } @@ -128,7 +131,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { // Deposit ERC20 tokens to custody and call an omnichain smart contract function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).transferFrom(msg.sender, address(custody), amount); + IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); emit Deposit(msg.sender, receiver, amount, asset, payload); } diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index dc58cb83..b6d07c9d 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -2,6 +2,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; @@ -11,10 +12,13 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; // The Gateway contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { + using SafeERC20 for IERC20; + error ExecutionFailed(); error SendFailed(); error InsufficientETHAmount(); error ZeroAddress(); + error ApprovalFailed(); address public custody; address public tssAddress; @@ -73,19 +77,19 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens - IERC20(token).approve(to, 0); - IERC20(token).approve(to, amount); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!IERC20(token).approve(to, amount)) revert ApprovalFailed(); // Execute the call on the target contract bytes memory result = _execute(to, data); // Reset approval - IERC20(token).approve(to, 0); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); // Transfer any remaining tokens back to the custody contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).transfer(address(custody), remainingBalance); + IERC20(token).safeTransfer(address(custody), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -95,7 +99,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade // Transfer specified token amount to ERC20Custody and emits event function sendERC20(bytes calldata recipient, address token, uint256 amount) external { - IERC20(token).transferFrom(msg.sender, address(custody), amount); + IERC20(token).safeTransferFrom(msg.sender, address(custody), amount); emit SendERC20(recipient, token, amount); } diff --git a/contracts/prototypes/evm/Receiver.sol b/contracts/prototypes/evm/Receiver.sol index f25a1932..d3609af2 100644 --- a/contracts/prototypes/evm/Receiver.sol +++ b/contracts/prototypes/evm/Receiver.sol @@ -2,8 +2,11 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; contract Receiver { + using SafeERC20 for IERC20; + event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); event ReceivedC(address sender, uint256 amount, address token, address destination); @@ -22,7 +25,7 @@ contract Receiver { // Function using IERC20 function receiveC(uint256 amount, address token, address destination) external { // Transfer tokens from the Gateway contract to the destination address - IERC20(token).transferFrom(msg.sender, destination, amount); + IERC20(token).safeTransferFrom(msg.sender, destination, amount); emit ReceivedC(msg.sender, amount, token, destination); } diff --git a/contracts/prototypes/zevm/Sender.sol b/contracts/prototypes/zevm/Sender.sol index a495cc66..12001e50 100644 --- a/contracts/prototypes/zevm/Sender.sol +++ b/contracts/prototypes/zevm/Sender.sol @@ -7,6 +7,7 @@ import "../../zevm/interfaces/IZRC20.sol"; contract Sender { address public gateway; + error ApprovalFailed(); constructor(address _gateway) { gateway = _gateway; @@ -27,7 +28,7 @@ contract Sender { bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); // Approve gateway to withdraw - IZRC20(zrc20).approve(gateway, amount); + if(!IZRC20(zrc20).approve(gateway, amount)) revert ApprovalFailed(); // Pass encoded call to gateway IGatewayZEVM(gateway).withdrawAndCall(receiver, amount, zrc20, message); diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index 74e05a97..c3df4c95 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index 57a384fd..14dc490b 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -15,6 +15,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [], name: "ExecutionFailed", @@ -443,7 +448,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index eb345f93..14ae85cf 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -15,6 +15,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [], name: "DepositFailed", @@ -525,7 +530,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts index 7b19442e..afa09286 100644 --- a/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts @@ -201,7 +201,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ReceiverConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts index 65a4efd0..84db8a5d 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts @@ -21,6 +21,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [ { @@ -103,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderConstructorParams = | [signer?: Signer] From 0b1f89456a31eff3018dd1563e7190cb3e2dc40c Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 12:28:42 +0200 Subject: [PATCH 26/86] fix coderabbit comments --- contracts/prototypes/evm/ERC20CustodyNew.sol | 12 ++++++++---- contracts/prototypes/evm/GatewayEVM.sol | 17 ++++++++++------- .../prototypes/evm/GatewayEVMUpgradeTest.sol | 14 +++++++++----- contracts/prototypes/evm/Receiver.sol | 5 ++++- contracts/prototypes/zevm/Sender.sol | 3 ++- .../prototypes/evm/ERC20CustodyNew__factory.ts | 2 +- .../evm/GatewayEVMUpgradeTest__factory.ts | 7 ++++++- .../prototypes/evm/GatewayEVM__factory.ts | 7 ++++++- .../prototypes/evm/Receiver__factory.ts | 2 +- .../prototypes/zevm/Sender__factory.ts | 7 ++++++- 10 files changed, 53 insertions(+), 23 deletions(-) diff --git a/contracts/prototypes/evm/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol index 2dbf54a4..2a4adbb4 100644 --- a/contracts/prototypes/evm/ERC20CustodyNew.sol +++ b/contracts/prototypes/evm/ERC20CustodyNew.sol @@ -3,11 +3,15 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./interfaces.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; // As the current version, ERC20CustodyNew hold the ERC20s deposited on ZetaChain // This version include a functionality allowing to call a contract // ERC20Custody doesn't call smart contract directly, it passes through the Gateway contract -contract ERC20CustodyNew { +contract ERC20CustodyNew is ReentrancyGuard{ + using SafeERC20 for IERC20; + IGatewayEVM public gateway; event Withdraw(address indexed token, address indexed to, uint256 amount); @@ -18,15 +22,15 @@ contract ERC20CustodyNew { } // Withdraw is called by TSS address, it directly transfers the tokens to the destination address without contract call - function withdraw(address token, address to, uint256 amount) external { - IERC20(token).transfer(to, amount); + function withdraw(address token, address to, uint256 amount) external nonReentrant { + IERC20(token).safeTransfer(to, amount); emit Withdraw(token, to, amount); } // WithdrawAndCall is called by TSS address, it transfers the tokens and call a contract // For this, it passes through the Gateway contract, it transfers the tokens to the Gateway contract and then calls the contract - function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external { + function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external nonReentrant { // Transfer the tokens to the Gateway contract IERC20(token).transfer(address(gateway), amount); diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 43bf4046..171f7283 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -2,19 +2,22 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; - // The GatewayEVM contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { + using SafeERC20 for IERC20; + error ExecutionFailed(); error DepositFailed(); error InsufficientETHAmount(); error InsufficientERC20Amount(); error ZeroAddress(); + error ApprovalFailed(); address public custody; address public tssAddress; @@ -73,19 +76,19 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens - IERC20(token).approve(to, 0); - IERC20(token).approve(to, amount); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!IERC20(token).approve(to, amount)) revert ApprovalFailed(); // Execute the call on the target contract bytes memory result = _execute(to, data); // Reset approval - IERC20(token).approve(to, 0); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); // Transfer any remaining tokens back to the custody contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).transfer(address(custody), remainingBalance); + IERC20(token).safeTransfer(address(custody), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -108,7 +111,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { // Deposit ERC20 tokens to custody function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).transferFrom(msg.sender, address(custody), amount); + IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); emit Deposit(msg.sender, receiver, amount, asset, ""); } @@ -128,7 +131,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { // Deposit ERC20 tokens to custody and call an omnichain smart contract function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).transferFrom(msg.sender, address(custody), amount); + IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); emit Deposit(msg.sender, receiver, amount, asset, payload); } diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index dc58cb83..b6d07c9d 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -2,6 +2,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; @@ -11,10 +12,13 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; // The Gateway contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { + using SafeERC20 for IERC20; + error ExecutionFailed(); error SendFailed(); error InsufficientETHAmount(); error ZeroAddress(); + error ApprovalFailed(); address public custody; address public tssAddress; @@ -73,19 +77,19 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade bytes calldata data ) external returns (bytes memory) { // Approve the target contract to spend the tokens - IERC20(token).approve(to, 0); - IERC20(token).approve(to, amount); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!IERC20(token).approve(to, amount)) revert ApprovalFailed(); // Execute the call on the target contract bytes memory result = _execute(to, data); // Reset approval - IERC20(token).approve(to, 0); + if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); // Transfer any remaining tokens back to the custody contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).transfer(address(custody), remainingBalance); + IERC20(token).safeTransfer(address(custody), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -95,7 +99,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade // Transfer specified token amount to ERC20Custody and emits event function sendERC20(bytes calldata recipient, address token, uint256 amount) external { - IERC20(token).transferFrom(msg.sender, address(custody), amount); + IERC20(token).safeTransferFrom(msg.sender, address(custody), amount); emit SendERC20(recipient, token, amount); } diff --git a/contracts/prototypes/evm/Receiver.sol b/contracts/prototypes/evm/Receiver.sol index f25a1932..d3609af2 100644 --- a/contracts/prototypes/evm/Receiver.sol +++ b/contracts/prototypes/evm/Receiver.sol @@ -2,8 +2,11 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; contract Receiver { + using SafeERC20 for IERC20; + event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); event ReceivedC(address sender, uint256 amount, address token, address destination); @@ -22,7 +25,7 @@ contract Receiver { // Function using IERC20 function receiveC(uint256 amount, address token, address destination) external { // Transfer tokens from the Gateway contract to the destination address - IERC20(token).transferFrom(msg.sender, destination, amount); + IERC20(token).safeTransferFrom(msg.sender, destination, amount); emit ReceivedC(msg.sender, amount, token, destination); } diff --git a/contracts/prototypes/zevm/Sender.sol b/contracts/prototypes/zevm/Sender.sol index a495cc66..12001e50 100644 --- a/contracts/prototypes/zevm/Sender.sol +++ b/contracts/prototypes/zevm/Sender.sol @@ -7,6 +7,7 @@ import "../../zevm/interfaces/IZRC20.sol"; contract Sender { address public gateway; + error ApprovalFailed(); constructor(address _gateway) { gateway = _gateway; @@ -27,7 +28,7 @@ contract Sender { bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); // Approve gateway to withdraw - IZRC20(zrc20).approve(gateway, amount); + if(!IZRC20(zrc20).approve(gateway, amount)) revert ApprovalFailed(); // Pass encoded call to gateway IGatewayZEVM(gateway).withdrawAndCall(receiver, amount, zrc20, message); diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index 74e05a97..c3df4c95 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -144,7 +144,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index 57a384fd..14dc490b 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -15,6 +15,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [], name: "ExecutionFailed", @@ -443,7 +448,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index eb345f93..14ae85cf 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -15,6 +15,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [], name: "DepositFailed", @@ -525,7 +530,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts index 7b19442e..afa09286 100644 --- a/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/Receiver__factory.ts @@ -201,7 +201,7 @@ const _abi = [ ] as const; const _bytecode = - "0x608060405234801561001057600080fd5b50610bbf806100206000396000f3fe60806040526004361061003f5760003560e01c806352df08b6146100445780636fa220ad1461006d57806386c4519214610089578063f5db6b39146100a0575b600080fd5b34801561005057600080fd5b5061006b6004803603810190610066919061059f565b6100c9565b005b61008760048036038101906100829190610530565b61019b565b005b34801561009557600080fd5b5061009e6101df565b005b3480156100ac57600080fd5b506100c760048036038101906100c29190610478565b610218565b005b8173ffffffffffffffffffffffffffffffffffffffff166323b872dd3383866040518463ffffffff1660e01b8152600401610106939291906107ba565b602060405180830381600087803b15801561012057600080fd5b505af1158015610134573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101589190610503565b507fe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b329003384848460405161018e9493929190610844565b60405180910390a1505050565b7f87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee33348585856040516101d2959493929190610889565b60405180910390a1505050565b7fcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d8623360405161020e919061079f565b60405180910390a1565b7f463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c23384848460405161024d94939291906107f1565b60405180910390a1505050565b600061026d61026884610908565b6108e3565b905080838252602082019050828560208602820111156102905761028f610b1f565b5b60005b858110156102de57813567ffffffffffffffff8111156102b6576102b5610b1a565b5b8086016102c38982610435565b85526020850194506020840193505050600181019050610293565b5050509392505050565b60006102fb6102f684610934565b6108e3565b9050808382526020820190508285602086028201111561031e5761031d610b1f565b5b60005b8581101561034e57816103348882610463565b845260208401935060208301925050600181019050610321565b5050509392505050565b600061036b61036684610960565b6108e3565b90508281526020810184848401111561038757610386610b24565b5b610392848285610a78565b509392505050565b6000813590506103a981610b44565b92915050565b600082601f8301126103c4576103c3610b1a565b5b81356103d484826020860161025a565b91505092915050565b600082601f8301126103f2576103f1610b1a565b5b81356104028482602086016102e8565b91505092915050565b60008135905061041a81610b5b565b92915050565b60008151905061042f81610b5b565b92915050565b600082601f83011261044a57610449610b1a565b5b813561045a848260208601610358565b91505092915050565b60008135905061047281610b72565b92915050565b60008060006060848603121561049157610490610b2e565b5b600084013567ffffffffffffffff8111156104af576104ae610b29565b5b6104bb868287016103af565b935050602084013567ffffffffffffffff8111156104dc576104db610b29565b5b6104e8868287016103dd565b92505060406104f98682870161040b565b9150509250925092565b60006020828403121561051957610518610b2e565b5b600061052784828501610420565b91505092915050565b60008060006060848603121561054957610548610b2e565b5b600084013567ffffffffffffffff81111561056757610566610b29565b5b61057386828701610435565b935050602061058486828701610463565b92505060406105958682870161040b565b9150509250925092565b6000806000606084860312156105b8576105b7610b2e565b5b60006105c686828701610463565b93505060206105d78682870161039a565b92505060406105e88682870161039a565b9150509250925092565b60006105fe838361070f565b905092915050565b60006106128383610781565b60208301905092915050565b61062781610a30565b82525050565b6000610638826109b1565b61064281856109ec565b93508360208202850161065485610991565b8060005b85811015610690578484038952815161067185826105f2565b945061067c836109d2565b925060208a01995050600181019050610658565b50829750879550505050505092915050565b60006106ad826109bc565b6106b781856109fd565b93506106c2836109a1565b8060005b838110156106f35781516106da8882610606565b97506106e5836109df565b9250506001810190506106c6565b5085935050505092915050565b61070981610a42565b82525050565b600061071a826109c7565b6107248185610a0e565b9350610734818560208601610a87565b61073d81610b33565b840191505092915050565b6000610753826109c7565b61075d8185610a1f565b935061076d818560208601610a87565b61077681610b33565b840191505092915050565b61078a81610a6e565b82525050565b61079981610a6e565b82525050565b60006020820190506107b4600083018461061e565b92915050565b60006060820190506107cf600083018661061e565b6107dc602083018561061e565b6107e96040830184610790565b949350505050565b6000608082019050610806600083018761061e565b8181036020830152610818818661062d565b9050818103604083015261082c81856106a2565b905061083b6060830184610700565b95945050505050565b6000608082019050610859600083018761061e565b6108666020830186610790565b610873604083018561061e565b610880606083018461061e565b95945050505050565b600060a08201905061089e600083018861061e565b6108ab6020830187610790565b81810360408301526108bd8186610748565b90506108cc6060830185610790565b6108d96080830184610700565b9695505050505050565b60006108ed6108fe565b90506108f98282610aba565b919050565b6000604051905090565b600067ffffffffffffffff82111561092357610922610aeb565b5b602082029050602081019050919050565b600067ffffffffffffffff82111561094f5761094e610aeb565b5b602082029050602081019050919050565b600067ffffffffffffffff82111561097b5761097a610aeb565b5b61098482610b33565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000610a3b82610a4e565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610aa5578082015181840152602081019050610a8a565b83811115610ab4576000848401525b50505050565b610ac382610b33565b810181811067ffffffffffffffff82111715610ae257610ae1610aeb565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610b4d81610a30565b8114610b5857600080fd5b50565b610b6481610a42565b8114610b6f57600080fd5b50565b610b7b81610a6e565b8114610b8657600080fd5b5056fea2646970667358221220306904d1ac37a7038356263bf6701066c06915e4c044c26bee44a6014dd379e564736f6c63430008070033"; + "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"; type ReceiverConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts index 65a4efd0..84db8a5d 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/Sender__factory.ts @@ -21,6 +21,11 @@ const _abi = [ stateMutability: "nonpayable", type: "constructor", }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, { inputs: [ { @@ -103,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "0x608060405234801561001057600080fd5b50604051610b98380380610b988339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610a81806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105c8565b61009c565b005b61006a61027a565b604051610077919061072c565b60405180910390f35b61009a60048036038101906100959190610529565b61029e565b005b60008383836040516024016100b3939291906107fa565b6040516020818303038152906040527f6fa220ad000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d929190610747565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df91906104fc565b5060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161023f94939291906107a7565b600060405180830381600087803b15801561025957600080fd5b505af115801561026d573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102b5939291906107fa565b6040516020818303038152906040527f6fa220ad000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b815260040161038f929190610770565b600060405180830381600087803b1580156103a957600080fd5b505af11580156103bd573d6000803e3d6000fd5b505050505050505050565b60006103db6103d68461085d565b610838565b9050828152602081018484840111156103f7576103f66109e6565b5b61040284828561093f565b509392505050565b600061041d6104188461088e565b610838565b905082815260208101848484011115610439576104386109e6565b5b61044484828561093f565b509392505050565b60008135905061045b81610a06565b92915050565b60008135905061047081610a1d565b92915050565b60008151905061048581610a1d565b92915050565b600082601f8301126104a05761049f6109e1565b5b81356104b08482602086016103c8565b91505092915050565b600082601f8301126104ce576104cd6109e1565b5b81356104de84826020860161040a565b91505092915050565b6000813590506104f681610a34565b92915050565b600060208284031215610512576105116109f0565b5b600061052084828501610476565b91505092915050565b60008060008060808587031215610543576105426109f0565b5b600085013567ffffffffffffffff811115610561576105606109eb565b5b61056d8782880161048b565b945050602085013567ffffffffffffffff81111561058e5761058d6109eb565b5b61059a878288016104b9565b93505060406105ab878288016104e7565b92505060606105bc87828801610461565b91505092959194509250565b60008060008060008060c087890312156105e5576105e46109f0565b5b600087013567ffffffffffffffff811115610603576106026109eb565b5b61060f89828a0161048b565b965050602061062089828a016104e7565b955050604061063189828a0161044c565b945050606087013567ffffffffffffffff811115610652576106516109eb565b5b61065e89828a016104b9565b935050608061066f89828a016104e7565b92505060a061068089828a01610461565b9150509295509295509295565b610696816108f7565b82525050565b6106a581610909565b82525050565b60006106b6826108bf565b6106c081856108d5565b93506106d081856020860161094e565b6106d9816109f5565b840191505092915050565b60006106ef826108ca565b6106f981856108e6565b935061070981856020860161094e565b610712816109f5565b840191505092915050565b61072681610935565b82525050565b6000602082019050610741600083018461068d565b92915050565b600060408201905061075c600083018561068d565b610769602083018461071d565b9392505050565b6000604082019050818103600083015261078a81856106ab565b9050818103602083015261079e81846106ab565b90509392505050565b600060808201905081810360008301526107c181876106ab565b90506107d0602083018661071d565b6107dd604083018561068d565b81810360608301526107ef81846106ab565b905095945050505050565b6000606082019050818103600083015261081481866106e4565b9050610823602083018561071d565b610830604083018461069c565b949350505050565b6000610842610853565b905061084e8282610981565b919050565b6000604051905090565b600067ffffffffffffffff821115610878576108776109b2565b5b610881826109f5565b9050602081019050919050565b600067ffffffffffffffff8211156108a9576108a86109b2565b5b6108b2826109f5565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600061090282610915565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b8381101561096c578082015181840152602081019050610951565b8381111561097b576000848401525b50505050565b61098a826109f5565b810181811067ffffffffffffffff821117156109a9576109a86109b2565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a0f816108f7565b8114610a1a57600080fd5b50565b610a2681610909565b8114610a3157600080fd5b50565b610a3d81610935565b8114610a4857600080fd5b5056fea26469706673582212204c7f8b772fce05dd4ff723dce588569b060a09b273a1e74a4e86711f9bd86ff064736f6c63430008070033"; + "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"; type SenderConstructorParams = | [signer?: Signer] From 7db93ddcfdcc9ce5c6024717e0071f1182869725 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 13:04:36 +0200 Subject: [PATCH 27/86] fix yarn generate --- data/addresses.testnet.json | 42 +++++++++++++++++++ lib/types.ts | 1 + package.json | 2 +- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../evm/gatewayevm.sol/gatewayevm.go | 4 +- .../gatewayevmupgradetest.go | 4 +- .../prototypes/evm/receiver.sol/receiver.go | 2 +- .../prototypes/zevm/sender.sol/sender.go | 4 +- yarn.lock | 8 ++-- 9 files changed, 56 insertions(+), 13 deletions(-) diff --git a/data/addresses.testnet.json b/data/addresses.testnet.json index 3c4a9a9c..f75c2719 100644 --- a/data/addresses.testnet.json +++ b/data/addresses.testnet.json @@ -269,6 +269,48 @@ "chain_name": "btc_testnet", "type": "tss" }, + { + "address": "0x60E6b70bC2761f878Ff992276612F67FbABC1761", + "category": "messaging", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "connector" + }, + { + "address": "0xFDE448af6140a8702A1165c44A0895ebE24b0C02", + "category": "omnichain", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "erc20Custody" + }, + { + "address": "0x55122f7590164Ac222504436943FAB17B62F5d7d", + "category": "messaging", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "pauser" + }, + { + "address": "0x8531a5aB847ff5B22D855633C25ED1DA3255247e", + "category": "omnichain", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "tss" + }, + { + "address": "0x55122f7590164Ac222504436943FAB17B62F5d7d", + "category": "omnichain", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "tssUpdater" + }, + { + "address": "0x1432612E60cad487C857E7D38AFf57134916c902", + "category": "messaging", + "chain_id": 80002, + "chain_name": "amoy_testnet", + "type": "zetaToken" + }, { "address": "0x3963341dad121c9CD33046089395D66eBF20Fb03", "category": "messaging", diff --git a/lib/types.ts b/lib/types.ts index 93a49b79..651dc5c5 100644 --- a/lib/types.ts +++ b/lib/types.ts @@ -15,6 +15,7 @@ export type ParamSymbol = | "USDT.BSC" | "USDT.ETH"; export type ParamChainName = + | "amoy_testnet" | "bsc_mainnet" | "bsc_testnet" | "btc_mainnet" diff --git a/package.json b/package.json index fb23de87..c91e4aad 100644 --- a/package.json +++ b/package.json @@ -24,7 +24,7 @@ "@uniswap/v2-core": "^1.0.1", "@uniswap/v2-periphery": "^1.1.0-beta.0", "@uniswap/v3-periphery": "^1.4.3", - "@zetachain/networks": "8.0.0-rc1", + "@zetachain/networks": "8.0.0", "axios": "^1.6.5", "chai": "^4.3.6", "cpx": "^1.5.0", diff --git a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index 9f42a416..ad3442be 100644 --- a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 937bc51f..cfc2c21c 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -31,8 +31,8 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index 68b06e1e..49951a88 100644 --- a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -31,8 +31,8 @@ var ( // GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SendFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Send\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SendERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SendFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Send\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SendERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go b/pkg/contracts/prototypes/evm/receiver.sol/receiver.go index 102c632e..04b452fd 100644 --- a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go +++ b/pkg/contracts/prototypes/evm/receiver.sol/receiver.go @@ -32,7 +32,7 @@ var ( // ReceiverMetaData contains all meta data concerning the Receiver contract. var ReceiverMetaData = &bind.MetaData{ ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedD\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveC\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveD\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ReceiverABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/sender.sol/sender.go b/pkg/contracts/prototypes/zevm/sender.sol/sender.go index e8dcefeb..68b28f2f 100644 --- a/pkg/contracts/prototypes/zevm/sender.sol/sender.go +++ b/pkg/contracts/prototypes/zevm/sender.sol/sender.go @@ -31,8 +31,8 @@ var ( // SenderMetaData contains all meta data concerning the Sender contract. var SenderMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // SenderABI is the input ABI used to generate the binding from. diff --git a/yarn.lock b/yarn.lock index 146663a7..60a5b05d 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2262,10 +2262,10 @@ "@uniswap/v3-core" "1.0.0" base64-sol "1.0.1" -"@zetachain/networks@8.0.0-rc1": - version "8.0.0-rc1" - resolved "https://registry.yarnpkg.com/@zetachain/networks/-/networks-8.0.0-rc1.tgz#3ad8891a7e2120509ef560720c6fa573a0a0b73f" - integrity sha512-rw09aariRcNItoNYClHq6Gm2IUNoBOFHOO3VHNyN7krapbY0Jy4HCQQj8iq7oNWZyNfwDIxIqkiQURPvIfpsMw== +"@zetachain/networks@8.0.0": + version "8.0.0" + resolved "https://registry.yarnpkg.com/@zetachain/networks/-/networks-8.0.0.tgz#3e838bb6b14e4a8d381f95b4cbc2f1172e851e4e" + integrity sha512-I0HhH5qOGW0Jkjq5o5Mi6qGls6ycHnhWjc+r+Ud8u8YW+HU4lEUn4gvulxj+ccHKj3nV/0gEsmNrWRY9ct49nQ== dependencies: dotenv "^16.1.4" From 1e8af8850c2412d773b911e427415277812df057 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 14:42:18 +0200 Subject: [PATCH 28/86] generate --- package.json | 6 +++--- scripts/gatewayEVMdeposit.ts | 6 +++--- scripts/worker.ts | 16 ++++++++-------- 3 files changed, 14 insertions(+), 14 deletions(-) diff --git a/package.json b/package.json index fda82442..84fb951f 100644 --- a/package.json +++ b/package.json @@ -82,12 +82,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", + "localnet": "npx hardhat run scripts/worker.ts --network localhost", + "localnode": "npx hardhat node", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", - "tsc:watch": "npx tsc --watch", - "localnode": "npx hardhat node", - "localnet": "npx hardhat run scripts/worker.ts --network localhost" + "tsc:watch": "npx tsc --watch" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/scripts/gatewayEVMdeposit.ts b/scripts/gatewayEVMdeposit.ts index a6aa260e..2c5bd66a 100644 --- a/scripts/gatewayEVMdeposit.ts +++ b/scripts/gatewayEVMdeposit.ts @@ -15,6 +15,6 @@ async function main() { main() .then(() => process.exit(0)) .catch((error) => { - console.error(error); - process.exit(1); - }); \ No newline at end of file + console.error(error); + process.exit(1); + }); diff --git a/scripts/worker.ts b/scripts/worker.ts index 552a0b4f..b757b73a 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -10,7 +10,7 @@ const hre = require("hardhat"); export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; export const startLocalnet = async () => { - console.log('deploying contracts') + console.log("deploying contracts"); // EVM let receiverEVM: Contract; let gatewayEVM: Contract; @@ -89,7 +89,7 @@ export const startLocalnet = async () => { 1, 0, systemContract.address, - gatewayZEVM.address, + gatewayZEVM.address )) as ZRC20; console.log("ZEVM: ZRC20(TKN) contract deployed to:", ZRC20Contract.address); @@ -118,17 +118,17 @@ export const startLocalnet = async () => { console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); gatewayEVM.on("Deposit", (...args: Array) => { - console.log("EVM: GatewayEVM Deposit event:", args) - }) + console.log("EVM: GatewayEVM Deposit event:", args); + }); process.stdin.resume(); -} +}; startLocalnet() .then(() => { - console.log('Setup complete, monitoring events. Press CTRL+C to exit.'); + console.log("Setup complete, monitoring events. Press CTRL+C to exit."); }) .catch((error) => { - console.error('Failed to deploy contracts or set up listeners:', error); + console.error("Failed to deploy contracts or set up listeners:", error); process.exit(1); - }); \ No newline at end of file + }); From d94d8ff502f4011d986173f4d2c66e8c54c088fa Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 16:11:46 +0200 Subject: [PATCH 29/86] renamings --- .../evm/{Receiver.sol => ReceiverEVM.sol} | 2 +- .../zevm/{Sender.sol => SenderZEVM.sol} | 2 +- .../receiverevm.go} | 362 +++++++++--------- .../senderzevm.go} | 190 ++++----- scripts/worker.ts | 5 +- test/prototypes/GatewayEVM.spec.ts | 2 +- test/prototypes/GatewayEVMUpgrade.spec.ts | 2 +- test/prototypes/GatewayIntegration.spec.ts | 8 +- .../contracts/prototypes/evm/ReceiverEVM.ts | 336 ++++++++++++++++ .../contracts/prototypes/evm/index.ts | 2 +- .../contracts/prototypes/zevm/SenderZEVM.ts | 210 ++++++++++ .../contracts/prototypes/zevm/index.ts | 2 +- .../prototypes/evm/ReceiverEVM__factory.ts | 251 ++++++++++++ .../contracts/prototypes/evm/index.ts | 2 +- .../prototypes/zevm/SenderZEVM__factory.ts | 160 ++++++++ .../contracts/prototypes/zevm/index.ts | 2 +- typechain-types/hardhat.d.ts | 16 +- typechain-types/index.ts | 8 +- 18 files changed, 1260 insertions(+), 302 deletions(-) rename contracts/prototypes/evm/{Receiver.sol => ReceiverEVM.sol} (98%) rename contracts/prototypes/zevm/{Sender.sol => SenderZEVM.sol} (98%) rename pkg/contracts/prototypes/evm/{receiver.sol/receiver.go => receiverevm.sol/receiverevm.go} (65%) rename pkg/contracts/prototypes/zevm/{sender.sol/sender.go => senderzevm.sol/senderzevm.go} (58%) create mode 100644 typechain-types/contracts/prototypes/evm/ReceiverEVM.ts create mode 100644 typechain-types/contracts/prototypes/zevm/SenderZEVM.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts diff --git a/contracts/prototypes/evm/Receiver.sol b/contracts/prototypes/evm/ReceiverEVM.sol similarity index 98% rename from contracts/prototypes/evm/Receiver.sol rename to contracts/prototypes/evm/ReceiverEVM.sol index d3609af2..f7610f45 100644 --- a/contracts/prototypes/evm/Receiver.sol +++ b/contracts/prototypes/evm/ReceiverEVM.sol @@ -4,7 +4,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -contract Receiver { +contract ReceiverEVM { using SafeERC20 for IERC20; event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); diff --git a/contracts/prototypes/zevm/Sender.sol b/contracts/prototypes/zevm/SenderZEVM.sol similarity index 98% rename from contracts/prototypes/zevm/Sender.sol rename to contracts/prototypes/zevm/SenderZEVM.sol index 12001e50..003bffec 100644 --- a/contracts/prototypes/zevm/Sender.sol +++ b/contracts/prototypes/zevm/SenderZEVM.sol @@ -5,7 +5,7 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "./interfaces.sol"; import "../../zevm/interfaces/IZRC20.sol"; -contract Sender { +contract SenderZEVM { address public gateway; error ApprovalFailed(); diff --git a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go b/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go similarity index 65% rename from pkg/contracts/prototypes/evm/receiver.sol/receiver.go rename to pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go index 04b452fd..4517b1c8 100644 --- a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go +++ b/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package receiver +package receiverevm import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// ReceiverMetaData contains all meta data concerning the Receiver contract. -var ReceiverMetaData = &bind.MetaData{ +// ReceiverEVMMetaData contains all meta data concerning the ReceiverEVM contract. +var ReceiverEVMMetaData = &bind.MetaData{ ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedD\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveC\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveD\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } -// ReceiverABI is the input ABI used to generate the binding from. -// Deprecated: Use ReceiverMetaData.ABI instead. -var ReceiverABI = ReceiverMetaData.ABI +// ReceiverEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use ReceiverEVMMetaData.ABI instead. +var ReceiverEVMABI = ReceiverEVMMetaData.ABI -// ReceiverBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ReceiverMetaData.Bin instead. -var ReceiverBin = ReceiverMetaData.Bin +// ReceiverEVMBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ReceiverEVMMetaData.Bin instead. +var ReceiverEVMBin = ReceiverEVMMetaData.Bin -// DeployReceiver deploys a new Ethereum contract, binding an instance of Receiver to it. -func DeployReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Receiver, error) { - parsed, err := ReceiverMetaData.GetAbi() +// DeployReceiverEVM deploys a new Ethereum contract, binding an instance of ReceiverEVM to it. +func DeployReceiverEVM(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ReceiverEVM, error) { + parsed, err := ReceiverEVMMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } @@ -53,111 +53,111 @@ func DeployReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (comm return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ReceiverBin), backend) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ReceiverEVMBin), backend) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil + return address, tx, &ReceiverEVM{ReceiverEVMCaller: ReceiverEVMCaller{contract: contract}, ReceiverEVMTransactor: ReceiverEVMTransactor{contract: contract}, ReceiverEVMFilterer: ReceiverEVMFilterer{contract: contract}}, nil } -// Receiver is an auto generated Go binding around an Ethereum contract. -type Receiver struct { - ReceiverCaller // Read-only binding to the contract - ReceiverTransactor // Write-only binding to the contract - ReceiverFilterer // Log filterer for contract events +// ReceiverEVM is an auto generated Go binding around an Ethereum contract. +type ReceiverEVM struct { + ReceiverEVMCaller // Read-only binding to the contract + ReceiverEVMTransactor // Write-only binding to the contract + ReceiverEVMFilterer // Log filterer for contract events } -// ReceiverCaller is an auto generated read-only Go binding around an Ethereum contract. -type ReceiverCaller struct { +// ReceiverEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type ReceiverEVMCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ReceiverTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ReceiverTransactor struct { +// ReceiverEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ReceiverEVMTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ReceiverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ReceiverFilterer struct { +// ReceiverEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ReceiverEVMFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ReceiverSession is an auto generated Go binding around an Ethereum contract, +// ReceiverEVMSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ReceiverSession struct { - Contract *Receiver // Generic contract binding to set the session for +type ReceiverEVMSession struct { + Contract *ReceiverEVM // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ReceiverCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// ReceiverEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ReceiverCallerSession struct { - Contract *ReceiverCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type ReceiverEVMCallerSession struct { + Contract *ReceiverEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// ReceiverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// ReceiverEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ReceiverTransactorSession struct { - Contract *ReceiverTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type ReceiverEVMTransactorSession struct { + Contract *ReceiverEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ReceiverRaw is an auto generated low-level Go binding around an Ethereum contract. -type ReceiverRaw struct { - Contract *Receiver // Generic contract binding to access the raw methods on +// ReceiverEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type ReceiverEVMRaw struct { + Contract *ReceiverEVM // Generic contract binding to access the raw methods on } -// ReceiverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ReceiverCallerRaw struct { - Contract *ReceiverCaller // Generic read-only contract binding to access the raw methods on +// ReceiverEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ReceiverEVMCallerRaw struct { + Contract *ReceiverEVMCaller // Generic read-only contract binding to access the raw methods on } -// ReceiverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ReceiverTransactorRaw struct { - Contract *ReceiverTransactor // Generic write-only contract binding to access the raw methods on +// ReceiverEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ReceiverEVMTransactorRaw struct { + Contract *ReceiverEVMTransactor // Generic write-only contract binding to access the raw methods on } -// NewReceiver creates a new instance of Receiver, bound to a specific deployed contract. -func NewReceiver(address common.Address, backend bind.ContractBackend) (*Receiver, error) { - contract, err := bindReceiver(address, backend, backend, backend) +// NewReceiverEVM creates a new instance of ReceiverEVM, bound to a specific deployed contract. +func NewReceiverEVM(address common.Address, backend bind.ContractBackend) (*ReceiverEVM, error) { + contract, err := bindReceiverEVM(address, backend, backend, backend) if err != nil { return nil, err } - return &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil + return &ReceiverEVM{ReceiverEVMCaller: ReceiverEVMCaller{contract: contract}, ReceiverEVMTransactor: ReceiverEVMTransactor{contract: contract}, ReceiverEVMFilterer: ReceiverEVMFilterer{contract: contract}}, nil } -// NewReceiverCaller creates a new read-only instance of Receiver, bound to a specific deployed contract. -func NewReceiverCaller(address common.Address, caller bind.ContractCaller) (*ReceiverCaller, error) { - contract, err := bindReceiver(address, caller, nil, nil) +// NewReceiverEVMCaller creates a new read-only instance of ReceiverEVM, bound to a specific deployed contract. +func NewReceiverEVMCaller(address common.Address, caller bind.ContractCaller) (*ReceiverEVMCaller, error) { + contract, err := bindReceiverEVM(address, caller, nil, nil) if err != nil { return nil, err } - return &ReceiverCaller{contract: contract}, nil + return &ReceiverEVMCaller{contract: contract}, nil } -// NewReceiverTransactor creates a new write-only instance of Receiver, bound to a specific deployed contract. -func NewReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*ReceiverTransactor, error) { - contract, err := bindReceiver(address, nil, transactor, nil) +// NewReceiverEVMTransactor creates a new write-only instance of ReceiverEVM, bound to a specific deployed contract. +func NewReceiverEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*ReceiverEVMTransactor, error) { + contract, err := bindReceiverEVM(address, nil, transactor, nil) if err != nil { return nil, err } - return &ReceiverTransactor{contract: contract}, nil + return &ReceiverEVMTransactor{contract: contract}, nil } -// NewReceiverFilterer creates a new log filterer instance of Receiver, bound to a specific deployed contract. -func NewReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*ReceiverFilterer, error) { - contract, err := bindReceiver(address, nil, nil, filterer) +// NewReceiverEVMFilterer creates a new log filterer instance of ReceiverEVM, bound to a specific deployed contract. +func NewReceiverEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*ReceiverEVMFilterer, error) { + contract, err := bindReceiverEVM(address, nil, nil, filterer) if err != nil { return nil, err } - return &ReceiverFilterer{contract: contract}, nil + return &ReceiverEVMFilterer{contract: contract}, nil } -// bindReceiver binds a generic wrapper to an already deployed contract. -func bindReceiver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ReceiverMetaData.GetAbi() +// bindReceiverEVM binds a generic wrapper to an already deployed contract. +func bindReceiverEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ReceiverEVMMetaData.GetAbi() if err != nil { return nil, err } @@ -168,127 +168,127 @@ func bindReceiver(address common.Address, caller bind.ContractCaller, transactor // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_Receiver *ReceiverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Receiver.Contract.ReceiverCaller.contract.Call(opts, result, method, params...) +func (_ReceiverEVM *ReceiverEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ReceiverEVM.Contract.ReceiverEVMCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_Receiver *ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.Contract.ReceiverTransactor.contract.Transfer(opts) +func (_ReceiverEVM *ReceiverEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiverEVMTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Receiver *ReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Receiver.Contract.ReceiverTransactor.contract.Transact(opts, method, params...) +func (_ReceiverEVM *ReceiverEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiverEVMTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_Receiver *ReceiverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Receiver.Contract.contract.Call(opts, result, method, params...) +func (_ReceiverEVM *ReceiverEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ReceiverEVM.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_Receiver *ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.Contract.contract.Transfer(opts) +func (_ReceiverEVM *ReceiverEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ReceiverEVM.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Receiver *ReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Receiver.Contract.contract.Transact(opts, method, params...) +func (_ReceiverEVM *ReceiverEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ReceiverEVM.Contract.contract.Transact(opts, method, params...) } // ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. // // Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverTransactor) ReceiveA(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveA", str, num, flag) +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveA(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveA", str, num, flag) } // ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. // // Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveA(&_Receiver.TransactOpts, str, num, flag) +func (_ReceiverEVM *ReceiverEVMSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveA(&_ReceiverEVM.TransactOpts, str, num, flag) } // ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. // // Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverTransactorSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveA(&_Receiver.TransactOpts, str, num, flag) +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveA(&_ReceiverEVM.TransactOpts, str, num, flag) } // ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. // // Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverTransactor) ReceiveB(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveB", strs, nums, flag) +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveB(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveB", strs, nums, flag) } // ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. // // Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveB(&_Receiver.TransactOpts, strs, nums, flag) +func (_ReceiverEVM *ReceiverEVMSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveB(&_ReceiverEVM.TransactOpts, strs, nums, flag) } // ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. // // Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverTransactorSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveB(&_Receiver.TransactOpts, strs, nums, flag) +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveB(&_ReceiverEVM.TransactOpts, strs, nums, flag) } // ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. // // Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverTransactor) ReceiveC(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveC", amount, token, destination) +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveC(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveC", amount, token, destination) } // ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. // // Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveC(&_Receiver.TransactOpts, amount, token, destination) +func (_ReceiverEVM *ReceiverEVMSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveC(&_ReceiverEVM.TransactOpts, amount, token, destination) } // ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. // // Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverTransactorSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveC(&_Receiver.TransactOpts, amount, token, destination) +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveC(&_ReceiverEVM.TransactOpts, amount, token, destination) } // ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. // // Solidity: function receiveD() returns() -func (_Receiver *ReceiverTransactor) ReceiveD(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveD") +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveD(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveD") } // ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. // // Solidity: function receiveD() returns() -func (_Receiver *ReceiverSession) ReceiveD() (*types.Transaction, error) { - return _Receiver.Contract.ReceiveD(&_Receiver.TransactOpts) +func (_ReceiverEVM *ReceiverEVMSession) ReceiveD() (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveD(&_ReceiverEVM.TransactOpts) } // ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. // // Solidity: function receiveD() returns() -func (_Receiver *ReceiverTransactorSession) ReceiveD() (*types.Transaction, error) { - return _Receiver.Contract.ReceiveD(&_Receiver.TransactOpts) +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveD() (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveD(&_ReceiverEVM.TransactOpts) } -// ReceiverReceivedAIterator is returned from FilterReceivedA and is used to iterate over the raw logs and unpacked data for ReceivedA events raised by the Receiver contract. -type ReceiverReceivedAIterator struct { - Event *ReceiverReceivedA // Event containing the contract specifics and raw log +// ReceiverEVMReceivedAIterator is returned from FilterReceivedA and is used to iterate over the raw logs and unpacked data for ReceivedA events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedAIterator struct { + Event *ReceiverEVMReceivedA // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -302,7 +302,7 @@ type ReceiverReceivedAIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedAIterator) Next() bool { +func (it *ReceiverEVMReceivedAIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -311,7 +311,7 @@ func (it *ReceiverReceivedAIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverReceivedA) + it.Event = new(ReceiverEVMReceivedA) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -326,7 +326,7 @@ func (it *ReceiverReceivedAIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverReceivedA) + it.Event = new(ReceiverEVMReceivedA) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -342,19 +342,19 @@ func (it *ReceiverReceivedAIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedAIterator) Error() error { +func (it *ReceiverEVMReceivedAIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverReceivedAIterator) Close() error { +func (it *ReceiverEVMReceivedAIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverReceivedA represents a ReceivedA event raised by the Receiver contract. -type ReceiverReceivedA struct { +// ReceiverEVMReceivedA represents a ReceivedA event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedA struct { Sender common.Address Value *big.Int Str string @@ -366,21 +366,21 @@ type ReceiverReceivedA struct { // FilterReceivedA is a free log retrieval operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. // // Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) FilterReceivedA(opts *bind.FilterOpts) (*ReceiverReceivedAIterator, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedA(opts *bind.FilterOpts) (*ReceiverEVMReceivedAIterator, error) { - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedA") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedA") if err != nil { return nil, err } - return &ReceiverReceivedAIterator{contract: _Receiver.contract, event: "ReceivedA", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedAIterator{contract: _ReceiverEVM.contract, event: "ReceivedA", logs: logs, sub: sub}, nil } // WatchReceivedA is a free log subscription operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. // // Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) WatchReceivedA(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedA) (event.Subscription, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedA(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedA) (event.Subscription, error) { - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedA") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedA") if err != nil { return nil, err } @@ -390,8 +390,8 @@ func (_Receiver *ReceiverFilterer) WatchReceivedA(opts *bind.WatchOpts, sink cha select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedA) - if err := _Receiver.contract.UnpackLog(event, "ReceivedA", log); err != nil { + event := new(ReceiverEVMReceivedA) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedA", log); err != nil { return err } event.Raw = log @@ -415,18 +415,18 @@ func (_Receiver *ReceiverFilterer) WatchReceivedA(opts *bind.WatchOpts, sink cha // ParseReceivedA is a log parse operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. // // Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) ParseReceivedA(log types.Log) (*ReceiverReceivedA, error) { - event := new(ReceiverReceivedA) - if err := _Receiver.contract.UnpackLog(event, "ReceivedA", log); err != nil { +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedA(log types.Log) (*ReceiverEVMReceivedA, error) { + event := new(ReceiverEVMReceivedA) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedA", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverReceivedBIterator is returned from FilterReceivedB and is used to iterate over the raw logs and unpacked data for ReceivedB events raised by the Receiver contract. -type ReceiverReceivedBIterator struct { - Event *ReceiverReceivedB // Event containing the contract specifics and raw log +// ReceiverEVMReceivedBIterator is returned from FilterReceivedB and is used to iterate over the raw logs and unpacked data for ReceivedB events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedBIterator struct { + Event *ReceiverEVMReceivedB // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -440,7 +440,7 @@ type ReceiverReceivedBIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedBIterator) Next() bool { +func (it *ReceiverEVMReceivedBIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -449,7 +449,7 @@ func (it *ReceiverReceivedBIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverReceivedB) + it.Event = new(ReceiverEVMReceivedB) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -464,7 +464,7 @@ func (it *ReceiverReceivedBIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverReceivedB) + it.Event = new(ReceiverEVMReceivedB) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -480,19 +480,19 @@ func (it *ReceiverReceivedBIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedBIterator) Error() error { +func (it *ReceiverEVMReceivedBIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverReceivedBIterator) Close() error { +func (it *ReceiverEVMReceivedBIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverReceivedB represents a ReceivedB event raised by the Receiver contract. -type ReceiverReceivedB struct { +// ReceiverEVMReceivedB represents a ReceivedB event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedB struct { Sender common.Address Strs []string Nums []*big.Int @@ -503,21 +503,21 @@ type ReceiverReceivedB struct { // FilterReceivedB is a free log retrieval operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. // // Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) FilterReceivedB(opts *bind.FilterOpts) (*ReceiverReceivedBIterator, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedB(opts *bind.FilterOpts) (*ReceiverEVMReceivedBIterator, error) { - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedB") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedB") if err != nil { return nil, err } - return &ReceiverReceivedBIterator{contract: _Receiver.contract, event: "ReceivedB", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedBIterator{contract: _ReceiverEVM.contract, event: "ReceivedB", logs: logs, sub: sub}, nil } // WatchReceivedB is a free log subscription operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. // // Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) WatchReceivedB(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedB) (event.Subscription, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedB(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedB) (event.Subscription, error) { - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedB") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedB") if err != nil { return nil, err } @@ -527,8 +527,8 @@ func (_Receiver *ReceiverFilterer) WatchReceivedB(opts *bind.WatchOpts, sink cha select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedB) - if err := _Receiver.contract.UnpackLog(event, "ReceivedB", log); err != nil { + event := new(ReceiverEVMReceivedB) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedB", log); err != nil { return err } event.Raw = log @@ -552,18 +552,18 @@ func (_Receiver *ReceiverFilterer) WatchReceivedB(opts *bind.WatchOpts, sink cha // ParseReceivedB is a log parse operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. // // Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) ParseReceivedB(log types.Log) (*ReceiverReceivedB, error) { - event := new(ReceiverReceivedB) - if err := _Receiver.contract.UnpackLog(event, "ReceivedB", log); err != nil { +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedB(log types.Log) (*ReceiverEVMReceivedB, error) { + event := new(ReceiverEVMReceivedB) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedB", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverReceivedCIterator is returned from FilterReceivedC and is used to iterate over the raw logs and unpacked data for ReceivedC events raised by the Receiver contract. -type ReceiverReceivedCIterator struct { - Event *ReceiverReceivedC // Event containing the contract specifics and raw log +// ReceiverEVMReceivedCIterator is returned from FilterReceivedC and is used to iterate over the raw logs and unpacked data for ReceivedC events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedCIterator struct { + Event *ReceiverEVMReceivedC // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -577,7 +577,7 @@ type ReceiverReceivedCIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedCIterator) Next() bool { +func (it *ReceiverEVMReceivedCIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -586,7 +586,7 @@ func (it *ReceiverReceivedCIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverReceivedC) + it.Event = new(ReceiverEVMReceivedC) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -601,7 +601,7 @@ func (it *ReceiverReceivedCIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverReceivedC) + it.Event = new(ReceiverEVMReceivedC) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -617,19 +617,19 @@ func (it *ReceiverReceivedCIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedCIterator) Error() error { +func (it *ReceiverEVMReceivedCIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverReceivedCIterator) Close() error { +func (it *ReceiverEVMReceivedCIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverReceivedC represents a ReceivedC event raised by the Receiver contract. -type ReceiverReceivedC struct { +// ReceiverEVMReceivedC represents a ReceivedC event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedC struct { Sender common.Address Amount *big.Int Token common.Address @@ -640,21 +640,21 @@ type ReceiverReceivedC struct { // FilterReceivedC is a free log retrieval operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. // // Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) FilterReceivedC(opts *bind.FilterOpts) (*ReceiverReceivedCIterator, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedC(opts *bind.FilterOpts) (*ReceiverEVMReceivedCIterator, error) { - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedC") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedC") if err != nil { return nil, err } - return &ReceiverReceivedCIterator{contract: _Receiver.contract, event: "ReceivedC", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedCIterator{contract: _ReceiverEVM.contract, event: "ReceivedC", logs: logs, sub: sub}, nil } // WatchReceivedC is a free log subscription operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. // // Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) WatchReceivedC(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedC) (event.Subscription, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedC(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedC) (event.Subscription, error) { - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedC") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedC") if err != nil { return nil, err } @@ -664,8 +664,8 @@ func (_Receiver *ReceiverFilterer) WatchReceivedC(opts *bind.WatchOpts, sink cha select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedC) - if err := _Receiver.contract.UnpackLog(event, "ReceivedC", log); err != nil { + event := new(ReceiverEVMReceivedC) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedC", log); err != nil { return err } event.Raw = log @@ -689,18 +689,18 @@ func (_Receiver *ReceiverFilterer) WatchReceivedC(opts *bind.WatchOpts, sink cha // ParseReceivedC is a log parse operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. // // Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) ParseReceivedC(log types.Log) (*ReceiverReceivedC, error) { - event := new(ReceiverReceivedC) - if err := _Receiver.contract.UnpackLog(event, "ReceivedC", log); err != nil { +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedC(log types.Log) (*ReceiverEVMReceivedC, error) { + event := new(ReceiverEVMReceivedC) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedC", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverReceivedDIterator is returned from FilterReceivedD and is used to iterate over the raw logs and unpacked data for ReceivedD events raised by the Receiver contract. -type ReceiverReceivedDIterator struct { - Event *ReceiverReceivedD // Event containing the contract specifics and raw log +// ReceiverEVMReceivedDIterator is returned from FilterReceivedD and is used to iterate over the raw logs and unpacked data for ReceivedD events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedDIterator struct { + Event *ReceiverEVMReceivedD // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -714,7 +714,7 @@ type ReceiverReceivedDIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedDIterator) Next() bool { +func (it *ReceiverEVMReceivedDIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -723,7 +723,7 @@ func (it *ReceiverReceivedDIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverReceivedD) + it.Event = new(ReceiverEVMReceivedD) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -738,7 +738,7 @@ func (it *ReceiverReceivedDIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverReceivedD) + it.Event = new(ReceiverEVMReceivedD) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -754,19 +754,19 @@ func (it *ReceiverReceivedDIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedDIterator) Error() error { +func (it *ReceiverEVMReceivedDIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverReceivedDIterator) Close() error { +func (it *ReceiverEVMReceivedDIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverReceivedD represents a ReceivedD event raised by the Receiver contract. -type ReceiverReceivedD struct { +// ReceiverEVMReceivedD represents a ReceivedD event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedD struct { Sender common.Address Raw types.Log // Blockchain specific contextual infos } @@ -774,21 +774,21 @@ type ReceiverReceivedD struct { // FilterReceivedD is a free log retrieval operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. // // Solidity: event ReceivedD(address sender) -func (_Receiver *ReceiverFilterer) FilterReceivedD(opts *bind.FilterOpts) (*ReceiverReceivedDIterator, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedD(opts *bind.FilterOpts) (*ReceiverEVMReceivedDIterator, error) { - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedD") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedD") if err != nil { return nil, err } - return &ReceiverReceivedDIterator{contract: _Receiver.contract, event: "ReceivedD", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedDIterator{contract: _ReceiverEVM.contract, event: "ReceivedD", logs: logs, sub: sub}, nil } // WatchReceivedD is a free log subscription operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. // // Solidity: event ReceivedD(address sender) -func (_Receiver *ReceiverFilterer) WatchReceivedD(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedD) (event.Subscription, error) { +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedD(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedD) (event.Subscription, error) { - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedD") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedD") if err != nil { return nil, err } @@ -798,8 +798,8 @@ func (_Receiver *ReceiverFilterer) WatchReceivedD(opts *bind.WatchOpts, sink cha select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedD) - if err := _Receiver.contract.UnpackLog(event, "ReceivedD", log); err != nil { + event := new(ReceiverEVMReceivedD) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedD", log); err != nil { return err } event.Raw = log @@ -823,9 +823,9 @@ func (_Receiver *ReceiverFilterer) WatchReceivedD(opts *bind.WatchOpts, sink cha // ParseReceivedD is a log parse operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. // // Solidity: event ReceivedD(address sender) -func (_Receiver *ReceiverFilterer) ParseReceivedD(log types.Log) (*ReceiverReceivedD, error) { - event := new(ReceiverReceivedD) - if err := _Receiver.contract.UnpackLog(event, "ReceivedD", log); err != nil { +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedD(log types.Log) (*ReceiverEVMReceivedD, error) { + event := new(ReceiverEVMReceivedD) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedD", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/zevm/sender.sol/sender.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go similarity index 58% rename from pkg/contracts/prototypes/zevm/sender.sol/sender.go rename to pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 68b28f2f..bdacbc90 100644 --- a/pkg/contracts/prototypes/zevm/sender.sol/sender.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package sender +package senderzevm import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// SenderMetaData contains all meta data concerning the Sender contract. -var SenderMetaData = &bind.MetaData{ +// SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. +var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x608060405234801561001057600080fd5b50604051610bcd380380610bcd8339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610ab6806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105fd565b61009c565b005b61006a6102af565b6040516100779190610761565b60405180910390f35b61009a6004803603810190610095919061055e565b6102d3565b005b60008383836040516024016100b39392919061082f565b6040516020818303038152906040527f6fa220ad000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d92919061077c565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df9190610531565b610215576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161027494939291906107dc565b600060405180830381600087803b15801561028e57600080fd5b505af11580156102a2573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102ea9392919061082f565b6040516020818303038152906040527f6fa220ad000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b81526004016103c49291906107a5565b600060405180830381600087803b1580156103de57600080fd5b505af11580156103f2573d6000803e3d6000fd5b505050505050505050565b600061041061040b84610892565b61086d565b90508281526020810184848401111561042c5761042b610a1b565b5b610437848285610974565b509392505050565b600061045261044d846108c3565b61086d565b90508281526020810184848401111561046e5761046d610a1b565b5b610479848285610974565b509392505050565b60008135905061049081610a3b565b92915050565b6000813590506104a581610a52565b92915050565b6000815190506104ba81610a52565b92915050565b600082601f8301126104d5576104d4610a16565b5b81356104e58482602086016103fd565b91505092915050565b600082601f83011261050357610502610a16565b5b813561051384826020860161043f565b91505092915050565b60008135905061052b81610a69565b92915050565b60006020828403121561054757610546610a25565b5b6000610555848285016104ab565b91505092915050565b6000806000806080858703121561057857610577610a25565b5b600085013567ffffffffffffffff81111561059657610595610a20565b5b6105a2878288016104c0565b945050602085013567ffffffffffffffff8111156105c3576105c2610a20565b5b6105cf878288016104ee565b93505060406105e08782880161051c565b92505060606105f187828801610496565b91505092959194509250565b60008060008060008060c0878903121561061a57610619610a25565b5b600087013567ffffffffffffffff81111561063857610637610a20565b5b61064489828a016104c0565b965050602061065589828a0161051c565b955050604061066689828a01610481565b945050606087013567ffffffffffffffff81111561068757610686610a20565b5b61069389828a016104ee565b93505060806106a489828a0161051c565b92505060a06106b589828a01610496565b9150509295509295509295565b6106cb8161092c565b82525050565b6106da8161093e565b82525050565b60006106eb826108f4565b6106f5818561090a565b9350610705818560208601610983565b61070e81610a2a565b840191505092915050565b6000610724826108ff565b61072e818561091b565b935061073e818560208601610983565b61074781610a2a565b840191505092915050565b61075b8161096a565b82525050565b600060208201905061077660008301846106c2565b92915050565b600060408201905061079160008301856106c2565b61079e6020830184610752565b9392505050565b600060408201905081810360008301526107bf81856106e0565b905081810360208301526107d381846106e0565b90509392505050565b600060808201905081810360008301526107f681876106e0565b90506108056020830186610752565b61081260408301856106c2565b818103606083015261082481846106e0565b905095945050505050565b600060608201905081810360008301526108498186610719565b90506108586020830185610752565b61086560408301846106d1565b949350505050565b6000610877610888565b905061088382826109b6565b919050565b6000604051905090565b600067ffffffffffffffff8211156108ad576108ac6109e7565b5b6108b682610a2a565b9050602081019050919050565b600067ffffffffffffffff8211156108de576108dd6109e7565b5b6108e782610a2a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b60006109378261094a565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156109a1578082015181840152602081019050610986565b838111156109b0576000848401525b50505050565b6109bf82610a2a565b810181811067ffffffffffffffff821117156109de576109dd6109e7565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a448161092c565b8114610a4f57600080fd5b50565b610a5b8161093e565b8114610a6657600080fd5b50565b610a728161096a565b8114610a7d57600080fd5b5056fea26469706673582212207ff292cddefa93d840595b1d5e59d45e6e76c033cd54ef125432f30ae987a10564736f6c63430008070033", + Bin: "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", } -// SenderABI is the input ABI used to generate the binding from. -// Deprecated: Use SenderMetaData.ABI instead. -var SenderABI = SenderMetaData.ABI +// SenderZEVMABI is the input ABI used to generate the binding from. +// Deprecated: Use SenderZEVMMetaData.ABI instead. +var SenderZEVMABI = SenderZEVMMetaData.ABI -// SenderBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use SenderMetaData.Bin instead. -var SenderBin = SenderMetaData.Bin +// SenderZEVMBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use SenderZEVMMetaData.Bin instead. +var SenderZEVMBin = SenderZEVMMetaData.Bin -// DeploySender deploys a new Ethereum contract, binding an instance of Sender to it. -func DeploySender(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address) (common.Address, *types.Transaction, *Sender, error) { - parsed, err := SenderMetaData.GetAbi() +// DeploySenderZEVM deploys a new Ethereum contract, binding an instance of SenderZEVM to it. +func DeploySenderZEVM(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address) (common.Address, *types.Transaction, *SenderZEVM, error) { + parsed, err := SenderZEVMMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } @@ -53,111 +53,111 @@ func DeploySender(auth *bind.TransactOpts, backend bind.ContractBackend, _gatewa return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(SenderBin), backend, _gateway) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(SenderZEVMBin), backend, _gateway) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil + return address, tx, &SenderZEVM{SenderZEVMCaller: SenderZEVMCaller{contract: contract}, SenderZEVMTransactor: SenderZEVMTransactor{contract: contract}, SenderZEVMFilterer: SenderZEVMFilterer{contract: contract}}, nil } -// Sender is an auto generated Go binding around an Ethereum contract. -type Sender struct { - SenderCaller // Read-only binding to the contract - SenderTransactor // Write-only binding to the contract - SenderFilterer // Log filterer for contract events +// SenderZEVM is an auto generated Go binding around an Ethereum contract. +type SenderZEVM struct { + SenderZEVMCaller // Read-only binding to the contract + SenderZEVMTransactor // Write-only binding to the contract + SenderZEVMFilterer // Log filterer for contract events } -// SenderCaller is an auto generated read-only Go binding around an Ethereum contract. -type SenderCaller struct { +// SenderZEVMCaller is an auto generated read-only Go binding around an Ethereum contract. +type SenderZEVMCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// SenderTransactor is an auto generated write-only Go binding around an Ethereum contract. -type SenderTransactor struct { +// SenderZEVMTransactor is an auto generated write-only Go binding around an Ethereum contract. +type SenderZEVMTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// SenderFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type SenderFilterer struct { +// SenderZEVMFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type SenderZEVMFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// SenderSession is an auto generated Go binding around an Ethereum contract, +// SenderZEVMSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type SenderSession struct { - Contract *Sender // Generic contract binding to set the session for +type SenderZEVMSession struct { + Contract *SenderZEVM // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// SenderCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// SenderZEVMCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type SenderCallerSession struct { - Contract *SenderCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type SenderZEVMCallerSession struct { + Contract *SenderZEVMCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// SenderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// SenderZEVMTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type SenderTransactorSession struct { - Contract *SenderTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type SenderZEVMTransactorSession struct { + Contract *SenderZEVMTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// SenderRaw is an auto generated low-level Go binding around an Ethereum contract. -type SenderRaw struct { - Contract *Sender // Generic contract binding to access the raw methods on +// SenderZEVMRaw is an auto generated low-level Go binding around an Ethereum contract. +type SenderZEVMRaw struct { + Contract *SenderZEVM // Generic contract binding to access the raw methods on } -// SenderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type SenderCallerRaw struct { - Contract *SenderCaller // Generic read-only contract binding to access the raw methods on +// SenderZEVMCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type SenderZEVMCallerRaw struct { + Contract *SenderZEVMCaller // Generic read-only contract binding to access the raw methods on } -// SenderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type SenderTransactorRaw struct { - Contract *SenderTransactor // Generic write-only contract binding to access the raw methods on +// SenderZEVMTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type SenderZEVMTransactorRaw struct { + Contract *SenderZEVMTransactor // Generic write-only contract binding to access the raw methods on } -// NewSender creates a new instance of Sender, bound to a specific deployed contract. -func NewSender(address common.Address, backend bind.ContractBackend) (*Sender, error) { - contract, err := bindSender(address, backend, backend, backend) +// NewSenderZEVM creates a new instance of SenderZEVM, bound to a specific deployed contract. +func NewSenderZEVM(address common.Address, backend bind.ContractBackend) (*SenderZEVM, error) { + contract, err := bindSenderZEVM(address, backend, backend, backend) if err != nil { return nil, err } - return &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil + return &SenderZEVM{SenderZEVMCaller: SenderZEVMCaller{contract: contract}, SenderZEVMTransactor: SenderZEVMTransactor{contract: contract}, SenderZEVMFilterer: SenderZEVMFilterer{contract: contract}}, nil } -// NewSenderCaller creates a new read-only instance of Sender, bound to a specific deployed contract. -func NewSenderCaller(address common.Address, caller bind.ContractCaller) (*SenderCaller, error) { - contract, err := bindSender(address, caller, nil, nil) +// NewSenderZEVMCaller creates a new read-only instance of SenderZEVM, bound to a specific deployed contract. +func NewSenderZEVMCaller(address common.Address, caller bind.ContractCaller) (*SenderZEVMCaller, error) { + contract, err := bindSenderZEVM(address, caller, nil, nil) if err != nil { return nil, err } - return &SenderCaller{contract: contract}, nil + return &SenderZEVMCaller{contract: contract}, nil } -// NewSenderTransactor creates a new write-only instance of Sender, bound to a specific deployed contract. -func NewSenderTransactor(address common.Address, transactor bind.ContractTransactor) (*SenderTransactor, error) { - contract, err := bindSender(address, nil, transactor, nil) +// NewSenderZEVMTransactor creates a new write-only instance of SenderZEVM, bound to a specific deployed contract. +func NewSenderZEVMTransactor(address common.Address, transactor bind.ContractTransactor) (*SenderZEVMTransactor, error) { + contract, err := bindSenderZEVM(address, nil, transactor, nil) if err != nil { return nil, err } - return &SenderTransactor{contract: contract}, nil + return &SenderZEVMTransactor{contract: contract}, nil } -// NewSenderFilterer creates a new log filterer instance of Sender, bound to a specific deployed contract. -func NewSenderFilterer(address common.Address, filterer bind.ContractFilterer) (*SenderFilterer, error) { - contract, err := bindSender(address, nil, nil, filterer) +// NewSenderZEVMFilterer creates a new log filterer instance of SenderZEVM, bound to a specific deployed contract. +func NewSenderZEVMFilterer(address common.Address, filterer bind.ContractFilterer) (*SenderZEVMFilterer, error) { + contract, err := bindSenderZEVM(address, nil, nil, filterer) if err != nil { return nil, err } - return &SenderFilterer{contract: contract}, nil + return &SenderZEVMFilterer{contract: contract}, nil } -// bindSender binds a generic wrapper to an already deployed contract. -func bindSender(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := SenderMetaData.GetAbi() +// bindSenderZEVM binds a generic wrapper to an already deployed contract. +func bindSenderZEVM(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := SenderZEVMMetaData.GetAbi() if err != nil { return nil, err } @@ -168,46 +168,46 @@ func bindSender(address common.Address, caller bind.ContractCaller, transactor b // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_Sender *SenderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Sender.Contract.SenderCaller.contract.Call(opts, result, method, params...) +func (_SenderZEVM *SenderZEVMRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _SenderZEVM.Contract.SenderZEVMCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_Sender *SenderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Sender.Contract.SenderTransactor.contract.Transfer(opts) +func (_SenderZEVM *SenderZEVMRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SenderZEVM.Contract.SenderZEVMTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Sender *SenderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Sender.Contract.SenderTransactor.contract.Transact(opts, method, params...) +func (_SenderZEVM *SenderZEVMRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SenderZEVM.Contract.SenderZEVMTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_Sender *SenderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Sender.Contract.contract.Call(opts, result, method, params...) +func (_SenderZEVM *SenderZEVMCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _SenderZEVM.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_Sender *SenderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Sender.Contract.contract.Transfer(opts) +func (_SenderZEVM *SenderZEVMTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SenderZEVM.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_Sender *SenderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Sender.Contract.contract.Transact(opts, method, params...) +func (_SenderZEVM *SenderZEVMTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SenderZEVM.Contract.contract.Transact(opts, method, params...) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_Sender *SenderCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { +func (_SenderZEVM *SenderZEVMCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _Sender.contract.Call(opts, &out, "gateway") + err := _SenderZEVM.contract.Call(opts, &out, "gateway") if err != nil { return *new(common.Address), err @@ -222,55 +222,55 @@ func (_Sender *SenderCaller) Gateway(opts *bind.CallOpts) (common.Address, error // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_Sender *SenderSession) Gateway() (common.Address, error) { - return _Sender.Contract.Gateway(&_Sender.CallOpts) +func (_SenderZEVM *SenderZEVMSession) Gateway() (common.Address, error) { + return _SenderZEVM.Contract.Gateway(&_SenderZEVM.CallOpts) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_Sender *SenderCallerSession) Gateway() (common.Address, error) { - return _Sender.Contract.Gateway(&_Sender.CallOpts) +func (_SenderZEVM *SenderZEVMCallerSession) Gateway() (common.Address, error) { + return _SenderZEVM.Contract.Gateway(&_SenderZEVM.CallOpts) } // CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. // // Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactor) CallReceiver(opts *bind.TransactOpts, receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.contract.Transact(opts, "callReceiver", receiver, str, num, flag) +func (_SenderZEVM *SenderZEVMTransactor) CallReceiver(opts *bind.TransactOpts, receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.contract.Transact(opts, "callReceiver", receiver, str, num, flag) } // CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. // // Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) +func (_SenderZEVM *SenderZEVMSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.Contract.CallReceiver(&_SenderZEVM.TransactOpts, receiver, str, num, flag) } // CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. // // Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactorSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) +func (_SenderZEVM *SenderZEVMTransactorSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.Contract.CallReceiver(&_SenderZEVM.TransactOpts, receiver, str, num, flag) } // WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. // // Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactor) WithdrawAndCallReceiver(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.contract.Transact(opts, "withdrawAndCallReceiver", receiver, amount, zrc20, str, num, flag) +func (_SenderZEVM *SenderZEVMTransactor) WithdrawAndCallReceiver(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.contract.Transact(opts, "withdrawAndCallReceiver", receiver, amount, zrc20, str, num, flag) } // WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. // // Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) +func (_SenderZEVM *SenderZEVMSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.Contract.WithdrawAndCallReceiver(&_SenderZEVM.TransactOpts, receiver, amount, zrc20, str, num, flag) } // WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. // // Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactorSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) +func (_SenderZEVM *SenderZEVMTransactorSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _SenderZEVM.Contract.WithdrawAndCallReceiver(&_SenderZEVM.TransactOpts, receiver, amount, zrc20, str, num, flag) } diff --git a/scripts/worker.ts b/scripts/worker.ts index b757b73a..9403ce88 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -29,7 +29,7 @@ export const startLocalnet = async () => { [ownerEVM, ownerZEVM, destination, tssAddress, ...addrs] = await ethers.getSigners(); // Prepare EVM const TestERC20 = await ethers.getContractFactory("TestERC20"); - const ReceiverEVM = await ethers.getContractFactory("Receiver"); + const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); @@ -103,7 +103,7 @@ export const startLocalnet = async () => { console.log(`ZEVM: ${ownerZEVM.address} approved GatewayZEVM ${gatewayZEVM.address} 100TKN`); // including abi of gatewayZEVM events, so hardhat can decode them automatically - const senderArtifact = await hre.artifacts.readArtifact("Sender"); + const senderArtifact = await hre.artifacts.readArtifact("SenderZEVM"); const gatewayZEVMArtifact = await hre.artifacts.readArtifact("GatewayZEVM"); const senderABI = [ ...senderArtifact.abi, @@ -119,6 +119,7 @@ export const startLocalnet = async () => { gatewayEVM.on("Deposit", (...args: Array) => { console.log("EVM: GatewayEVM Deposit event:", args); + console.log("payload: ", args[5].args["payload"]); }); process.stdin.resume(); diff --git a/test/prototypes/GatewayEVM.spec.ts b/test/prototypes/GatewayEVM.spec.ts index 1937900b..0d43e9ce 100644 --- a/test/prototypes/GatewayEVM.spec.ts +++ b/test/prototypes/GatewayEVM.spec.ts @@ -11,7 +11,7 @@ describe("GatewayEVM inbound", function () { beforeEach(async function () { const TestERC20 = await ethers.getContractFactory("TestERC20"); - const Receiver = await ethers.getContractFactory("Receiver"); + const Receiver = await ethers.getContractFactory("ReceiverEVM"); const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); [owner, destination, tssAddress] = await ethers.getSigners(); diff --git a/test/prototypes/GatewayEVMUpgrade.spec.ts b/test/prototypes/GatewayEVMUpgrade.spec.ts index 60357e36..85589907 100644 --- a/test/prototypes/GatewayEVMUpgrade.spec.ts +++ b/test/prototypes/GatewayEVMUpgrade.spec.ts @@ -11,7 +11,7 @@ describe("GatewayEVM upgrade", function () { beforeEach(async function () { const TestERC20 = await ethers.getContractFactory("TestERC20"); - const Receiver = await ethers.getContractFactory("Receiver"); + const Receiver = await ethers.getContractFactory("ReceiverEVM"); const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); [owner, destination, randomSigner, tssAddress] = await ethers.getSigners(); diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 2c529432..849cec02 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -29,7 +29,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { [ownerEVM, ownerZEVM, destination, tssAddress, ...addrs] = await ethers.getSigners(); // Prepare EVM const TestERC20 = await ethers.getContractFactory("TestERC20"); - const ReceiverEVM = await ethers.getContractFactory("Receiver"); + const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); @@ -89,7 +89,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { await ZRC20Contract.connect(ownerZEVM).approve(gatewayZEVM.address, parseEther("100")); // including abi of gatewayZEVM events, so hardhat can decode them automatically - const senderArtifact = await hre.artifacts.readArtifact("Sender"); + const senderArtifact = await hre.artifacts.readArtifact("SenderZEVM"); const gatewayZEVMArtifact = await hre.artifacts.readArtifact("GatewayZEVM"); const senderABI = [ ...senderArtifact.abi, @@ -110,8 +110,8 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); - const callTx = await gatewayZEVM.connect(ownerZEVM).call(ethers.utils.arrayify(addrs[0].address), message); - await expect(callTx).to.emit(gatewayZEVM, "Call").withArgs(ownerZEVM.address, addrs[0].address, message); + const callTx = await gatewayZEVM.connect(ownerZEVM).call(ethers.utils.arrayify(receiverEVM.address), message); + await expect(callTx).to.emit(gatewayZEVM, "Call").withArgs(ownerZEVM.address, receiverEVM.address, message); // Get message from events const callTxReceipt = await callTx.wait(); diff --git a/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts b/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts new file mode 100644 index 00000000..a1d97ed8 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts @@ -0,0 +1,336 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ReceiverEVMInterface extends utils.Interface { + functions: { + "receiveA(string,uint256,bool)": FunctionFragment; + "receiveB(string[],uint256[],bool)": FunctionFragment; + "receiveC(uint256,address,address)": FunctionFragment; + "receiveD()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" | "receiveD" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "receiveA", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "receiveB", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "receiveC", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "receiveD", values?: undefined): string; + + decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveC", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "receiveD", data: BytesLike): Result; + + events: { + "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; + "ReceivedB(address,string[],uint256[],bool)": EventFragment; + "ReceivedC(address,uint256,address,address)": EventFragment; + "ReceivedD(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedC"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedD"): EventFragment; +} + +export interface ReceivedAEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedAEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedAEventObject +>; + +export type ReceivedAEventFilter = TypedEventFilter; + +export interface ReceivedBEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedBEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedBEventObject +>; + +export type ReceivedBEventFilter = TypedEventFilter; + +export interface ReceivedCEventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedCEvent = TypedEvent< + [string, BigNumber, string, string], + ReceivedCEventObject +>; + +export type ReceivedCEventFilter = TypedEventFilter; + +export interface ReceivedDEventObject { + sender: string; +} +export type ReceivedDEvent = TypedEvent<[string], ReceivedDEventObject>; + +export type ReceivedDEventFilter = TypedEventFilter; + +export interface ReceiverEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ReceiverEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + receiveD(overrides?: CallOverrides): Promise; + }; + + filters: { + "ReceivedA(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + ReceivedA( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedAEventFilter; + + "ReceivedB(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + ReceivedB( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedBEventFilter; + + "ReceivedC(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; + ReceivedC( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedCEventFilter; + + "ReceivedD(address)"(sender?: null): ReceivedDEventFilter; + ReceivedD(sender?: null): ReceivedDEventFilter; + }; + + estimateGas: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + receiveA( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + receiveB( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveC( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveD( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 356b9286..939b9af8 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -6,5 +6,5 @@ export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { GatewayEVM } from "./GatewayEVM"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; -export type { Receiver } from "./Receiver"; +export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/contracts/prototypes/zevm/SenderZEVM.ts b/typechain-types/contracts/prototypes/zevm/SenderZEVM.ts new file mode 100644 index 00000000..26711238 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/SenderZEVM.ts @@ -0,0 +1,210 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface SenderZEVMInterface extends utils.Interface { + functions: { + "callReceiver(bytes,string,uint256,bool)": FunctionFragment; + "gateway()": FunctionFragment; + "withdrawAndCallReceiver(bytes,uint256,address,string,uint256,bool)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "callReceiver" + | "gateway" + | "withdrawAndCallReceiver" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "callReceiver", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdrawAndCallReceiver", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "callReceiver", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCallReceiver", + data: BytesLike + ): Result; + + events: {}; +} + +export interface SenderZEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: SenderZEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + callReceiver( + receiver: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + gateway(overrides?: CallOverrides): Promise; + + withdrawAndCallReceiver( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts index 0bf18c3c..e6090cc6 100644 --- a/typechain-types/contracts/prototypes/zevm/index.ts +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -6,5 +6,5 @@ export type { zrc20NewSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { GatewayZEVM } from "./GatewayZEVM"; -export type { Sender } from "./Sender"; +export type { SenderZEVM } from "./SenderZEVM"; export type { TestZContract } from "./TestZContract"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts new file mode 100644 index 00000000..b290f45e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts @@ -0,0 +1,251 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ReceiverEVM, + ReceiverEVMInterface, +} from "../../../../contracts/prototypes/evm/ReceiverEVM"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedA", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedB", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedC", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedD", + type: "event", + }, + { + inputs: [ + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveA", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "receiveB", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "receiveC", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "receiveD", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ReceiverEVMConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ReceiverEVMConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ReceiverEVM__factory extends ContractFactory { + constructor(...args: ReceiverEVMConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): ReceiverEVM { + return super.attach(address) as ReceiverEVM; + } + override connect(signer: Signer): ReceiverEVM__factory { + return super.connect(signer) as ReceiverEVM__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ReceiverEVMInterface { + return new utils.Interface(_abi) as ReceiverEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ReceiverEVM { + return new Contract(address, _abi, signerOrProvider) as ReceiverEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index d00427f1..b7a35400 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -5,5 +5,5 @@ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; -export { Receiver__factory } from "./Receiver__factory"; +export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts new file mode 100644 index 00000000..154c7ad8 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -0,0 +1,160 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + SenderZEVM, + SenderZEVMInterface, +} from "../../../../contracts/prototypes/zevm/SenderZEVM"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "callReceiver", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "string", + name: "str", + type: "string", + }, + { + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "withdrawAndCallReceiver", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type SenderZEVMConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: SenderZEVMConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class SenderZEVM__factory extends ContractFactory { + constructor(...args: SenderZEVMConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(_gateway, overrides || {}) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, overrides || {}); + } + override attach(address: string): SenderZEVM { + return super.attach(address) as SenderZEVM; + } + override connect(signer: Signer): SenderZEVM__factory { + return super.connect(signer) as SenderZEVM__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): SenderZEVMInterface { + return new utils.Interface(_abi) as SenderZEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): SenderZEVM { + return new Contract(address, _abi, signerOrProvider) as SenderZEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts index 54162241..389b7ace 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -4,5 +4,5 @@ export * as zrc20NewSol from "./ZRC20New.sol"; export * as interfacesSol from "./interfaces.sol"; export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; -export { Sender__factory } from "./Sender__factory"; +export { SenderZEVM__factory } from "./SenderZEVM__factory"; export { TestZContract__factory } from "./TestZContract__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index e7b1e088..6f78440d 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -349,9 +349,9 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "Receiver", + name: "ReceiverEVM", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions @@ -365,9 +365,9 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "Sender", + name: "SenderZEVM", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "TestZContract", signerOrOptions?: ethers.Signer | FactoryOptions @@ -870,10 +870,10 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "Receiver", + name: "ReceiverEVM", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "TestERC20", address: string, @@ -890,10 +890,10 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "Sender", + name: "SenderZEVM", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "TestZContract", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index a2eabf95..f17533ca 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -164,16 +164,16 @@ export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEV export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory"; -export type { Receiver } from "./contracts/prototypes/evm/Receiver"; -export { Receiver__factory } from "./factories/contracts/prototypes/evm/Receiver__factory"; +export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; +export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; -export type { Sender } from "./contracts/prototypes/zevm/Sender"; -export { Sender__factory } from "./factories/contracts/prototypes/zevm/Sender__factory"; +export type { SenderZEVM } from "./contracts/prototypes/zevm/SenderZEVM"; +export { SenderZEVM__factory } from "./factories/contracts/prototypes/zevm/SenderZEVM__factory"; export type { TestZContract } from "./contracts/prototypes/zevm/TestZContract"; export { TestZContract__factory } from "./factories/contracts/prototypes/zevm/TestZContract__factory"; export type { ZRC20Errors } from "./contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors"; From 290a84e93dfd38996cc62614319d10bc9f79753a Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 16:39:00 +0200 Subject: [PATCH 30/86] add simple task to call receiver --- hardhat.config.ts | 1 + scripts/gatewayEVMdeposit.ts | 20 -------------------- scripts/readme.md | 16 ++++++++++++++++ scripts/worker.ts | 12 +++++++++--- tasks/localnet.ts | 26 ++++++++++++++++++++++++++ 5 files changed, 52 insertions(+), 23 deletions(-) delete mode 100644 scripts/gatewayEVMdeposit.ts create mode 100644 scripts/readme.md create mode 100644 tasks/localnet.ts diff --git a/hardhat.config.ts b/hardhat.config.ts index 263a02c4..8fdc1844 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -7,6 +7,7 @@ import "uniswap-v2-deploy-plugin"; import "solidity-coverage"; import "hardhat-gas-reporter"; import "./tasks/addresses"; +import "./tasks/localnet"; import "@openzeppelin/hardhat-upgrades"; import { getHardhatConfigNetworks } from "@zetachain/networks"; diff --git a/scripts/gatewayEVMdeposit.ts b/scripts/gatewayEVMdeposit.ts deleted file mode 100644 index 2c5bd66a..00000000 --- a/scripts/gatewayEVMdeposit.ts +++ /dev/null @@ -1,20 +0,0 @@ -import { ethers } from "hardhat"; - -const hre = require("hardhat"); - -async function main() { - const gatewayEVMAddress = "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309"; - const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", gatewayEVMAddress); - let [, , destination] = await ethers.getSigners(); - - const deposit = await gatewayEVM["deposit(address)"](destination.address, { value: ethers.utils.parseEther("1") }); - - console.log("deposit hash:", deposit.hash); -} - -main() - .then(() => process.exit(0)) - .catch((error) => { - console.error(error); - process.exit(1); - }); diff --git a/scripts/readme.md b/scripts/readme.md new file mode 100644 index 00000000..6c9254c3 --- /dev/null +++ b/scripts/readme.md @@ -0,0 +1,16 @@ +## Worker script + +To start local hardhat node execute: + +``` +yarn localnode +``` + +To start localnet using local hardhat: +``` +yarn localnet +``` +This will run worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. + + + diff --git a/scripts/worker.ts b/scripts/worker.ts index 9403ce88..f1ac5c64 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -117,9 +117,15 @@ export const startLocalnet = async () => { await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); - gatewayEVM.on("Deposit", (...args: Array) => { - console.log("EVM: GatewayEVM Deposit event:", args); - console.log("payload: ", args[5].args["payload"]); + gatewayZEVM.on("Call", async (...args: Array) => { + console.log("Worker: Call event on GatewayZEVM."); + console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); + const executeTx = await gatewayEVM.execute(receiverEVM.address, args[3].args.message, { value: 0 }); + await executeTx.wait(); + }); + + receiverEVM.on("ReceivedA", () => { + console.log("ReceiverEVM: receiveA called!"); }); process.stdin.resume(); diff --git a/tasks/localnet.ts b/tasks/localnet.ts new file mode 100644 index 00000000..aa4fa049 --- /dev/null +++ b/tasks/localnet.ts @@ -0,0 +1,26 @@ +import { task } from "hardhat/config"; + +declare const hre: any; + +// Contains tasks to make it easier to interact with prototype contracts localnet +// To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses +// Otherwise, provide custom addresses as parameters + +task("call-evm-receiver", "calls evm receiver from zevm account") + .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") + .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") + .setAction(async (taskArgs) => { + const gatewayZEVM = await hre.ethers.getContractAt("GatewayZEVM", taskArgs.gatewayZEVM); + const receiverEVM = await hre.ethers.getContractAt("ReceiverEVM", taskArgs.receiverEVM); + + const str = "Hello!"; + const num = 42; + const flag = true; + + // Encode the function call data and call on zevm + const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + const callTx = await gatewayZEVM.call(hre.ethers.utils.arrayify(receiverEVM.address), message); + + await callTx.wait(); + console.log("ReceiverEVM called from ZEVM"); + }); From 5817d9a59bbf86a753166dc1c2873d5864b25b8f Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 17:16:17 +0200 Subject: [PATCH 31/86] use receiver from call event in worker script --- contracts/prototypes/zevm/GatewayZEVM.sol | 2 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 28 +++++++------------ scripts/readme.md | 1 + scripts/worker.ts | 2 +- tasks/localnet.ts | 2 +- test/prototypes/GatewayIntegration.spec.ts | 8 ++++-- .../contracts/prototypes/zevm/GatewayZEVM.ts | 4 +-- .../prototypes/zevm/GatewayZEVM__factory.ts | 4 +-- 8 files changed, 23 insertions(+), 28 deletions(-) diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index c4a97011..8df05fcd 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -18,7 +18,7 @@ contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error CallerIsNotFungibleModule(); error InvalidTarget(); - event Call(address indexed sender, bytes indexed receiver, bytes message); + event Call(address indexed sender, bytes receiver, bytes message); event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); /// @custom:oz-upgrades-unsafe-allow constructor diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 1d59c786..29356c14 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -38,8 +38,8 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. @@ -882,26 +882,22 @@ func (it *GatewayZEVMCallIterator) Close() error { // GatewayZEVMCall represents a Call event raised by the GatewayZEVM contract. type GatewayZEVMCall struct { Sender common.Address - Receiver common.Hash + Receiver []byte Message []byte Raw types.Log // Blockchain specific contextual infos } // FilterCall is a free log retrieval operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // -// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) -func (_GatewayZEVM *GatewayZEVMFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver [][]byte) (*GatewayZEVMCallIterator, error) { +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address) (*GatewayZEVMCallIterator, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + logs, sub, err := _GatewayZEVM.contract.FilterLogs(opts, "Call", senderRule) if err != nil { return nil, err } @@ -910,19 +906,15 @@ func (_GatewayZEVM *GatewayZEVMFilterer) FilterCall(opts *bind.FilterOpts, sende // WatchCall is a free log subscription operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // -// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) -func (_GatewayZEVM *GatewayZEVMFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayZEVMCall, sender []common.Address, receiver [][]byte) (event.Subscription, error) { +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_GatewayZEVM *GatewayZEVMFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayZEVMCall, sender []common.Address) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + logs, sub, err := _GatewayZEVM.contract.WatchLogs(opts, "Call", senderRule) if err != nil { return nil, err } @@ -956,7 +948,7 @@ func (_GatewayZEVM *GatewayZEVMFilterer) WatchCall(opts *bind.WatchOpts, sink ch // ParseCall is a log parse operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // -// Solidity: event Call(address indexed sender, bytes indexed receiver, bytes message) +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) func (_GatewayZEVM *GatewayZEVMFilterer) ParseCall(log types.Log) (*GatewayZEVMCall, error) { event := new(GatewayZEVMCall) if err := _GatewayZEVM.contract.UnpackLog(event, "Call", log); err != nil { diff --git a/scripts/readme.md b/scripts/readme.md index 6c9254c3..03b54976 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -11,6 +11,7 @@ To start localnet using local hardhat: yarn localnet ``` This will run worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. +Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. diff --git a/scripts/worker.ts b/scripts/worker.ts index f1ac5c64..52c68cc3 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -120,7 +120,7 @@ export const startLocalnet = async () => { gatewayZEVM.on("Call", async (...args: Array) => { console.log("Worker: Call event on GatewayZEVM."); console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); - const executeTx = await gatewayEVM.execute(receiverEVM.address, args[3].args.message, { value: 0 }); + const executeTx = await gatewayEVM.execute(args[1], args[2], { value: 0 }); await executeTx.wait(); }); diff --git a/tasks/localnet.ts b/tasks/localnet.ts index aa4fa049..f5a1c906 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -19,7 +19,7 @@ task("call-evm-receiver", "calls evm receiver from zevm account") // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); - const callTx = await gatewayZEVM.call(hre.ethers.utils.arrayify(receiverEVM.address), message); + const callTx = await gatewayZEVM.call(receiverEVM.address, message); await callTx.wait(); console.log("ReceiverEVM called from ZEVM"); diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 849cec02..ba700326 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -110,8 +110,10 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); - const callTx = await gatewayZEVM.connect(ownerZEVM).call(ethers.utils.arrayify(receiverEVM.address), message); - await expect(callTx).to.emit(gatewayZEVM, "Call").withArgs(ownerZEVM.address, receiverEVM.address, message); + const callTx = await gatewayZEVM.connect(ownerZEVM).call(receiverEVM.address, message); + await expect(callTx) + .to.emit(gatewayZEVM, "Call") + .withArgs(ownerZEVM.address, receiverEVM.address.toLowerCase(), message); // Get message from events const callTxReceipt = await callTx.wait(); @@ -179,7 +181,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { const expectedMessage = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); await expect(callTx) .to.emit(gatewayZEVM, "Call") - .withArgs(senderZEVM.address, receiverEVM.address, expectedMessage); + .withArgs(senderZEVM.address, receiverEVM.address.toLowerCase(), expectedMessage); const callEvent = callTxReceipt.events[0]; const callMessage = callEvent.args[2]; diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts index 04d1fed5..a9dde1e5 100644 --- a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -554,12 +554,12 @@ export interface GatewayZEVM extends BaseContract { "Call(address,bytes,bytes)"( sender?: PromiseOrValue | null, - receiver?: PromiseOrValue | null, + receiver?: null, message?: null ): CallEventFilter; Call( sender?: PromiseOrValue | null, - receiver?: PromiseOrValue | null, + receiver?: null, message?: null ): CallEventFilter; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index 041c238f..8b6596f6 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -82,7 +82,7 @@ const _abi = [ type: "address", }, { - indexed: true, + indexed: false, internalType: "bytes", name: "receiver", type: "bytes", @@ -477,7 +477,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] From f7d18fd363c0bee9c2de68173924824f0d0f27f3 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 18:49:06 +0200 Subject: [PATCH 32/86] add zcontract localnet task --- scripts/worker.ts | 24 ++++++++++++++++++++++++ tasks/localnet.ts | 14 ++++++++++++++ 2 files changed, 38 insertions(+) diff --git a/scripts/worker.ts b/scripts/worker.ts index 52c68cc3..2dfd26ae 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -23,6 +23,7 @@ export const startLocalnet = async () => { let ZRC20Contract: ZRC20; let systemContract: SystemContract; let gatewayZEVM: Contract; + let testZContract: Contract; let ownerZEVM: SignerWithAddress; let addrs: SignerWithAddress[]; @@ -80,6 +81,10 @@ export const startLocalnet = async () => { }); console.log("ZEVM: GatewayZEVM deployed to:", gatewayZEVM.address); + const TestZContract = await ethers.getContractFactory("TestZContract"); + testZContract = await TestZContract.deploy(); + console.log("ZEVM: TestZContract deployed to:", testZContract.address); + const ZRC20Factory = await ethers.getContractFactory("ZRC20New"); ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( "TOKEN", @@ -128,6 +133,25 @@ export const startLocalnet = async () => { console.log("ReceiverEVM: receiveA called!"); }); + gatewayEVM.on("Call", async (...args: Array) => { + console.log("Worker: Call event on GatewayEVM."); + console.log("Worker: Calling TestZContract through GatewayZEVM..."); + const executeTx = await gatewayZEVM + .connect(fungibleModuleSigner) + .execute( + [gatewayZEVM.address, fungibleModuleSigner.address, 1], + ZRC20Contract.address, + parseEther("0"), + testZContract.address, + args[2] + ); + await executeTx.wait(); + }); + + testZContract.on("ContextData", async () => { + console.log("TestZContract: onCrosschainCall called!"); + }); + process.stdin.resume(); }; diff --git a/tasks/localnet.ts b/tasks/localnet.ts index f5a1c906..410987b3 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -24,3 +24,17 @@ task("call-evm-receiver", "calls evm receiver from zevm account") await callTx.wait(); console.log("ReceiverEVM called from ZEVM"); }); + +task("call-zevm-zcontract", "calls zevm zcontract from evm account") + .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") + .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") + .setAction(async (taskArgs) => { + const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", taskArgs.gatewayEVM); + const zContract = await hre.ethers.getContractAt("TestZContract", taskArgs.zContract); + + const message = hre.ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); + const callTx = await gatewayEVM.call(zContract.address, message); + + await callTx.wait(); + console.log("TestZContract called from EVM"); + }); From 51ff6a2813f41dbbabe5d7cd1826f63a6fdf4827 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 18:51:09 +0200 Subject: [PATCH 33/86] cleanup --- scripts/readme.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/scripts/readme.md b/scripts/readme.md index 03b54976..432b9434 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -12,6 +12,3 @@ yarn localnet ``` This will run worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. - - - From b857b9caadae36794023d963eb639e464e11b724 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 2 Jul 2024 19:26:32 +0200 Subject: [PATCH 34/86] rename localnet script to worker --- package.json | 2 +- scripts/readme.md | 4 ++-- scripts/worker.ts | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/package.json b/package.json index 84fb951f..a791d26d 100644 --- a/package.json +++ b/package.json @@ -82,7 +82,7 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", - "localnet": "npx hardhat run scripts/worker.ts --network localhost", + "worker": "npx hardhat run scripts/worker.ts --network localhost", "localnode": "npx hardhat node", "prepublishOnly": "yarn build", "test": "npx hardhat test", diff --git a/scripts/readme.md b/scripts/readme.md index 432b9434..888a3f24 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -6,9 +6,9 @@ To start local hardhat node execute: yarn localnode ``` -To start localnet using local hardhat: +To start worker using local hardhat: ``` -yarn localnet +yarn worker ``` This will run worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. diff --git a/scripts/worker.ts b/scripts/worker.ts index 2dfd26ae..ad22dc7c 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -9,7 +9,7 @@ const hre = require("hardhat"); export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; -export const startLocalnet = async () => { +export const startWorker = async () => { console.log("deploying contracts"); // EVM let receiverEVM: Contract; @@ -155,7 +155,7 @@ export const startLocalnet = async () => { process.stdin.resume(); }; -startLocalnet() +startWorker() .then(() => { console.log("Setup complete, monitoring events. Press CTRL+C to exit."); }) From cbd7dcf07e0da071b6f765f4aad750d9cb3f6b60 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 11:08:09 +0200 Subject: [PATCH 35/86] run localnode and worker concurrently --- package.json | 7 ++--- scripts/readme.md | 10 +++---- yarn.lock | 68 +++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 73 insertions(+), 12 deletions(-) diff --git a/package.json b/package.json index a791d26d..5028c125 100644 --- a/package.json +++ b/package.json @@ -27,6 +27,7 @@ "@zetachain/networks": "8.0.0", "axios": "^1.6.5", "chai": "^4.3.6", + "concurrently": "^8.2.2", "cpx": "^1.5.0", "del-cli": "^5.0.0", "dotenv": "^16.0.0", @@ -82,12 +83,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", - "worker": "npx hardhat run scripts/worker.ts --network localhost", - "localnode": "npx hardhat node", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", - "tsc:watch": "npx tsc --watch" + "tsc:watch": "npx tsc --watch", + "worker": "npx hardhat run scripts/worker.ts --network localhost", + "localnet": "concurrently \"npx hardhat node\" \"yarn worker\"" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/scripts/readme.md b/scripts/readme.md index 888a3f24..7e04e34f 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -1,14 +1,10 @@ ## Worker script -To start local hardhat node execute: +To start localnet execute: ``` -yarn localnode +yarn localnet ``` -To start worker using local hardhat: -``` -yarn worker -``` -This will run worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. +This will run hardhat local node and worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. diff --git a/yarn.lock b/yarn.lock index 60a5b05d..eeb840c9 100644 --- a/yarn.lock +++ b/yarn.lock @@ -63,6 +63,13 @@ dependencies: regenerator-runtime "^0.13.11" +"@babel/runtime@^7.21.0": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.24.7.tgz#f4f0d5530e8dbdf59b3451b9b3e594b6ba082e12" + integrity sha512-UwgBRMjJP+xv857DCngvqXI3Iq6J4v0wXmwc6sapg+zyhbwmQX67LUEFrkK5tbyJ30jGuG3ZvWpBiB9LCy1kWw== + dependencies: + regenerator-runtime "^0.14.0" + "@chainsafe/as-sha256@^0.3.1": version "0.3.1" resolved "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-0.3.1.tgz" @@ -3526,6 +3533,21 @@ concat-stream@^1.6.0, concat-stream@^1.6.2: readable-stream "^2.2.2" typedarray "^0.0.6" +concurrently@^8.2.2: + version "8.2.2" + resolved "https://registry.yarnpkg.com/concurrently/-/concurrently-8.2.2.tgz#353141985c198cfa5e4a3ef90082c336b5851784" + integrity sha512-1dP4gpXFhei8IOtlXRE/T/4H88ElHgTiUzh71YUmtjTEHMSRS2Z/fgOxHSxxusGHogsRfxNq1vyAwxSC+EVyDg== + dependencies: + chalk "^4.1.2" + date-fns "^2.30.0" + lodash "^4.17.21" + rxjs "^7.8.1" + shell-quote "^1.8.1" + spawn-command "0.0.2" + supports-color "^8.1.1" + tree-kill "^1.2.2" + yargs "^17.7.2" + config-chain@^1.1.11: version "1.1.13" resolved "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz" @@ -3706,6 +3728,13 @@ data-view-byte-offset@^1.0.0: es-errors "^1.3.0" is-data-view "^1.0.1" +date-fns@^2.30.0: + version "2.30.0" + resolved "https://registry.yarnpkg.com/date-fns/-/date-fns-2.30.0.tgz#f367e644839ff57894ec6ac480de40cae4b0f4d0" + integrity sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw== + dependencies: + "@babel/runtime" "^7.21.0" + death@^1.1.0: version "1.1.0" resolved "https://registry.npmjs.org/death/-/death-1.1.0.tgz" @@ -8151,6 +8180,11 @@ regenerator-runtime@^0.13.11: resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz" integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg== +regenerator-runtime@^0.14.0: + version "0.14.1" + resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz#356ade10263f685dda125100cd862c1db895327f" + integrity sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw== + regex-cache@^0.4.2: version "0.4.4" resolved "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz" @@ -8452,6 +8486,13 @@ rxjs@^7.2.0, rxjs@^7.5.5: dependencies: tslib "^2.1.0" +rxjs@^7.8.1: + version "7.8.1" + resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543" + integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg== + dependencies: + tslib "^2.1.0" + safe-array-concat@^1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/safe-array-concat/-/safe-array-concat-1.1.2.tgz#81d77ee0c4e8b863635227c721278dd524c20edb" @@ -8686,7 +8727,7 @@ shebang-regex@^3.0.0: resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== -shell-quote@^1.6.1: +shell-quote@^1.6.1, shell-quote@^1.8.1: version "1.8.1" resolved "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.1.tgz" integrity sha512-6j1W9l1iAs/4xYBI1SYOVZyFcCis9b4KCLQ8fgAGG07QvzaRLVVRQvAy85yNmmZSjYjg4MWh4gNvlPujU/5LpA== @@ -8902,6 +8943,11 @@ source-map@~0.2.0: dependencies: amdefine ">=0.0.4" +spawn-command@0.0.2: + version "0.0.2" + resolved "https://registry.yarnpkg.com/spawn-command/-/spawn-command-0.0.2.tgz#9544e1a43ca045f8531aac1a48cb29bdae62338e" + integrity sha512-zC8zGoGkmc8J9ndvml8Xksr1Amk9qBujgbF0JAIWO7kXr43w0h/0GJNM/Vustixu+YE8N/MTrQ7N31FvHUACxQ== + spawndamnit@^2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/spawndamnit/-/spawndamnit-2.0.0.tgz" @@ -9171,7 +9217,7 @@ supports-color@6.0.0: dependencies: has-flag "^3.0.0" -supports-color@8.1.1: +supports-color@8.1.1, supports-color@^8.1.1: version "8.1.1" resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz" integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== @@ -9330,6 +9376,11 @@ tr46@~0.0.3: resolved "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz" integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== +tree-kill@^1.2.2: + version "1.2.2" + resolved "https://registry.yarnpkg.com/tree-kill/-/tree-kill-1.2.2.tgz#4ca09a9092c88b73a7cdc5e8a01b507b0790a0cc" + integrity sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A== + trim-newlines@^3.0.0: version "3.0.1" resolved "https://registry.npmjs.org/trim-newlines/-/trim-newlines-3.0.1.tgz" @@ -10077,6 +10128,19 @@ yargs@^17.7.1: y18n "^5.0.5" yargs-parser "^21.1.1" +yargs@^17.7.2: + version "17.7.2" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-17.7.2.tgz#991df39aca675a192b816e1e0363f9d75d2aa269" + integrity sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" + yn@3.1.1: version "3.1.1" resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz" From da9c0cd181ae33a34c28c69ca88f2a3bd4ec8b69 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 11:22:58 +0200 Subject: [PATCH 36/86] different colors and prefix for node and worker --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 5028c125..b501bec5 100644 --- a/package.json +++ b/package.json @@ -88,7 +88,7 @@ "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", "worker": "npx hardhat run scripts/worker.ts --network localhost", - "localnet": "concurrently \"npx hardhat node\" \"yarn worker\"" + "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" From f2a33712c2638c25195f323968d5061d641f6846 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 17:34:09 +0200 Subject: [PATCH 37/86] fixes after merge --- contracts/prototypes/evm/Receiver.sol | 37 - contracts/prototypes/evm/ReceiverEVM.sol | 24 +- package.json | 4 +- .../prototypes/evm/receiver.sol/receiver.go | 833 ------------------ .../evm/receiverevm.sol/receiverevm.go | 336 +++---- .../contracts/prototypes/evm/ReceiverEVM.ts | 326 +++---- .../contracts/prototypes/evm/index.ts | 1 - .../prototypes/evm/ReceiverEVM__factory.ts | 122 +-- .../contracts/prototypes/evm/index.ts | 1 - typechain-types/hardhat.d.ts | 9 - typechain-types/index.ts | 2 - 11 files changed, 418 insertions(+), 1277 deletions(-) delete mode 100644 contracts/prototypes/evm/Receiver.sol delete mode 100644 pkg/contracts/prototypes/evm/receiver.sol/receiver.go diff --git a/contracts/prototypes/evm/Receiver.sol b/contracts/prototypes/evm/Receiver.sol deleted file mode 100644 index 54fa499d..00000000 --- a/contracts/prototypes/evm/Receiver.sol +++ /dev/null @@ -1,37 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.7; - -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; - -contract Receiver { - using SafeERC20 for IERC20; - - event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag); - event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag); - event ReceivedERC20(address sender, uint256 amount, address token, address destination); - event ReceivedNoParams(address sender); - - // Payable function - function receivePayable(string memory str, uint256 num, bool flag) external payable { - emit ReceivedPayable(msg.sender, msg.value, str, num, flag); - } - - // Non-payable function - function receiveNonPayable(string[] memory strs, uint256[] memory nums, bool flag) external { - emit ReceivedNonPayable(msg.sender, strs, nums, flag); - } - - // Function using IERC20 - function receiveERC20(uint256 amount, address token, address destination) external { - // Transfer tokens from the Gateway contract to the destination address - IERC20(token).safeTransferFrom(msg.sender, destination, amount); - - emit ReceivedERC20(msg.sender, amount, token, destination); - } - - // Function without parameters - function receiveNoParams() external { - emit ReceivedNoParams(msg.sender); - } -} \ No newline at end of file diff --git a/contracts/prototypes/evm/ReceiverEVM.sol b/contracts/prototypes/evm/ReceiverEVM.sol index f7610f45..1ac1ad26 100644 --- a/contracts/prototypes/evm/ReceiverEVM.sol +++ b/contracts/prototypes/evm/ReceiverEVM.sol @@ -7,31 +7,31 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; contract ReceiverEVM { using SafeERC20 for IERC20; - event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag); - event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag); - event ReceivedC(address sender, uint256 amount, address token, address destination); - event ReceivedD(address sender); + event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag); + event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag); + event ReceivedERC20(address sender, uint256 amount, address token, address destination); + event ReceivedNoParams(address sender); // Payable function - function receiveA(string memory str, uint256 num, bool flag) external payable { - emit ReceivedA(msg.sender, msg.value, str, num, flag); + function receivePayable(string memory str, uint256 num, bool flag) external payable { + emit ReceivedPayable(msg.sender, msg.value, str, num, flag); } // Non-payable function - function receiveB(string[] memory strs, uint256[] memory nums, bool flag) external { - emit ReceivedB(msg.sender, strs, nums, flag); + function receiveNonPayable(string[] memory strs, uint256[] memory nums, bool flag) external { + emit ReceivedNonPayable(msg.sender, strs, nums, flag); } // Function using IERC20 - function receiveC(uint256 amount, address token, address destination) external { + function receiveERC20(uint256 amount, address token, address destination) external { // Transfer tokens from the Gateway contract to the destination address IERC20(token).safeTransferFrom(msg.sender, destination, amount); - emit ReceivedC(msg.sender, amount, token, destination); + emit ReceivedERC20(msg.sender, amount, token, destination); } // Function without parameters - function receiveD() external { - emit ReceivedD(msg.sender); + function receiveNoParams() external { + emit ReceivedNoParams(msg.sender); } } \ No newline at end of file diff --git a/package.json b/package.json index f392d2eb..8b33db5c 100644 --- a/package.json +++ b/package.json @@ -84,12 +84,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", - "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", - "worker": "npx hardhat run scripts/worker.ts --network localhost" + "worker": "npx hardhat run scripts/worker.ts --network localhost", + "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go b/pkg/contracts/prototypes/evm/receiver.sol/receiver.go deleted file mode 100644 index 8a976a45..00000000 --- a/pkg/contracts/prototypes/evm/receiver.sol/receiver.go +++ /dev/null @@ -1,833 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package receiver - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ReceiverMetaData contains all meta data concerning the Receiver contract. -var ReceiverMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveNoParams\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveNonPayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receivePayable\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", -} - -// ReceiverABI is the input ABI used to generate the binding from. -// Deprecated: Use ReceiverMetaData.ABI instead. -var ReceiverABI = ReceiverMetaData.ABI - -// ReceiverBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ReceiverMetaData.Bin instead. -var ReceiverBin = ReceiverMetaData.Bin - -// DeployReceiver deploys a new Ethereum contract, binding an instance of Receiver to it. -func DeployReceiver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Receiver, error) { - parsed, err := ReceiverMetaData.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(ReceiverBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil -} - -// Receiver is an auto generated Go binding around an Ethereum contract. -type Receiver struct { - ReceiverCaller // Read-only binding to the contract - ReceiverTransactor // Write-only binding to the contract - ReceiverFilterer // Log filterer for contract events -} - -// ReceiverCaller is an auto generated read-only Go binding around an Ethereum contract. -type ReceiverCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ReceiverTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ReceiverTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ReceiverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ReceiverFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ReceiverSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ReceiverSession struct { - Contract *Receiver // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ReceiverCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ReceiverCallerSession struct { - Contract *ReceiverCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ReceiverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ReceiverTransactorSession struct { - Contract *ReceiverTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ReceiverRaw is an auto generated low-level Go binding around an Ethereum contract. -type ReceiverRaw struct { - Contract *Receiver // Generic contract binding to access the raw methods on -} - -// ReceiverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ReceiverCallerRaw struct { - Contract *ReceiverCaller // Generic read-only contract binding to access the raw methods on -} - -// ReceiverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ReceiverTransactorRaw struct { - Contract *ReceiverTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewReceiver creates a new instance of Receiver, bound to a specific deployed contract. -func NewReceiver(address common.Address, backend bind.ContractBackend) (*Receiver, error) { - contract, err := bindReceiver(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &Receiver{ReceiverCaller: ReceiverCaller{contract: contract}, ReceiverTransactor: ReceiverTransactor{contract: contract}, ReceiverFilterer: ReceiverFilterer{contract: contract}}, nil -} - -// NewReceiverCaller creates a new read-only instance of Receiver, bound to a specific deployed contract. -func NewReceiverCaller(address common.Address, caller bind.ContractCaller) (*ReceiverCaller, error) { - contract, err := bindReceiver(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ReceiverCaller{contract: contract}, nil -} - -// NewReceiverTransactor creates a new write-only instance of Receiver, bound to a specific deployed contract. -func NewReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*ReceiverTransactor, error) { - contract, err := bindReceiver(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ReceiverTransactor{contract: contract}, nil -} - -// NewReceiverFilterer creates a new log filterer instance of Receiver, bound to a specific deployed contract. -func NewReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*ReceiverFilterer, error) { - contract, err := bindReceiver(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ReceiverFilterer{contract: contract}, nil -} - -// bindReceiver binds a generic wrapper to an already deployed contract. -func bindReceiver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ReceiverMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Receiver *ReceiverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Receiver.Contract.ReceiverCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Receiver *ReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.Contract.ReceiverTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Receiver *ReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Receiver.Contract.ReceiverTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Receiver *ReceiverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Receiver.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Receiver *ReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Receiver *ReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Receiver.Contract.contract.Transact(opts, method, params...) -} - -// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. -// -// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverTransactor) ReceiveERC20(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveERC20", amount, token, destination) -} - -// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. -// -// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverSession) ReceiveERC20(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveERC20(&_Receiver.TransactOpts, amount, token, destination) -} - -// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. -// -// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() -func (_Receiver *ReceiverTransactorSession) ReceiveERC20(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveERC20(&_Receiver.TransactOpts, amount, token, destination) -} - -// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. -// -// Solidity: function receiveNoParams() returns() -func (_Receiver *ReceiverTransactor) ReceiveNoParams(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveNoParams") -} - -// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. -// -// Solidity: function receiveNoParams() returns() -func (_Receiver *ReceiverSession) ReceiveNoParams() (*types.Transaction, error) { - return _Receiver.Contract.ReceiveNoParams(&_Receiver.TransactOpts) -} - -// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. -// -// Solidity: function receiveNoParams() returns() -func (_Receiver *ReceiverTransactorSession) ReceiveNoParams() (*types.Transaction, error) { - return _Receiver.Contract.ReceiveNoParams(&_Receiver.TransactOpts) -} - -// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. -// -// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverTransactor) ReceiveNonPayable(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receiveNonPayable", strs, nums, flag) -} - -// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. -// -// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverSession) ReceiveNonPayable(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveNonPayable(&_Receiver.TransactOpts, strs, nums, flag) -} - -// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. -// -// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() -func (_Receiver *ReceiverTransactorSession) ReceiveNonPayable(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceiveNonPayable(&_Receiver.TransactOpts, strs, nums, flag) -} - -// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. -// -// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverTransactor) ReceivePayable(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.contract.Transact(opts, "receivePayable", str, num, flag) -} - -// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. -// -// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverSession) ReceivePayable(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceivePayable(&_Receiver.TransactOpts, str, num, flag) -} - -// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. -// -// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() -func (_Receiver *ReceiverTransactorSession) ReceivePayable(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Receiver.Contract.ReceivePayable(&_Receiver.TransactOpts, str, num, flag) -} - -// ReceiverReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the Receiver contract. -type ReceiverReceivedERC20Iterator struct { - Event *ReceiverReceivedERC20 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedERC20Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedERC20Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ReceiverReceivedERC20Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ReceiverReceivedERC20 represents a ReceivedERC20 event raised by the Receiver contract. -type ReceiverReceivedERC20 struct { - Sender common.Address - Amount *big.Int - Token common.Address - Destination common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. -// -// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*ReceiverReceivedERC20Iterator, error) { - - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedERC20") - if err != nil { - return nil, err - } - return &ReceiverReceivedERC20Iterator{contract: _Receiver.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil -} - -// WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. -// -// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedERC20) (event.Subscription, error) { - - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedERC20") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedERC20) - if err := _Receiver.contract.UnpackLog(event, "ReceivedERC20", 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 -} - -// ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. -// -// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_Receiver *ReceiverFilterer) ParseReceivedERC20(log types.Log) (*ReceiverReceivedERC20, error) { - event := new(ReceiverReceivedERC20) - if err := _Receiver.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ReceiverReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the Receiver contract. -type ReceiverReceivedNoParamsIterator struct { - Event *ReceiverReceivedNoParams // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedNoParamsIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedNoParams) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedNoParams) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedNoParamsIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ReceiverReceivedNoParamsIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ReceiverReceivedNoParams represents a ReceivedNoParams event raised by the Receiver contract. -type ReceiverReceivedNoParams struct { - Sender common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. -// -// Solidity: event ReceivedNoParams(address sender) -func (_Receiver *ReceiverFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*ReceiverReceivedNoParamsIterator, error) { - - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedNoParams") - if err != nil { - return nil, err - } - return &ReceiverReceivedNoParamsIterator{contract: _Receiver.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil -} - -// WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. -// -// Solidity: event ReceivedNoParams(address sender) -func (_Receiver *ReceiverFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedNoParams) (event.Subscription, error) { - - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedNoParams") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedNoParams) - if err := _Receiver.contract.UnpackLog(event, "ReceivedNoParams", 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 -} - -// ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. -// -// Solidity: event ReceivedNoParams(address sender) -func (_Receiver *ReceiverFilterer) ParseReceivedNoParams(log types.Log) (*ReceiverReceivedNoParams, error) { - event := new(ReceiverReceivedNoParams) - if err := _Receiver.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ReceiverReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the Receiver contract. -type ReceiverReceivedNonPayableIterator struct { - Event *ReceiverReceivedNonPayable // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedNonPayableIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedNonPayable) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedNonPayable) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedNonPayableIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ReceiverReceivedNonPayableIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ReceiverReceivedNonPayable represents a ReceivedNonPayable event raised by the Receiver contract. -type ReceiverReceivedNonPayable struct { - Sender common.Address - Strs []string - Nums []*big.Int - Flag bool - Raw types.Log // Blockchain specific contextual infos -} - -// FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. -// -// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*ReceiverReceivedNonPayableIterator, error) { - - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedNonPayable") - if err != nil { - return nil, err - } - return &ReceiverReceivedNonPayableIterator{contract: _Receiver.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil -} - -// WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. -// -// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedNonPayable) (event.Subscription, error) { - - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedNonPayable") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedNonPayable) - if err := _Receiver.contract.UnpackLog(event, "ReceivedNonPayable", 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 -} - -// ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. -// -// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_Receiver *ReceiverFilterer) ParseReceivedNonPayable(log types.Log) (*ReceiverReceivedNonPayable, error) { - event := new(ReceiverReceivedNonPayable) - if err := _Receiver.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ReceiverReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the Receiver contract. -type ReceiverReceivedPayableIterator struct { - Event *ReceiverReceivedPayable // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ReceiverReceivedPayableIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedPayable) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ReceiverReceivedPayable) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverReceivedPayableIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ReceiverReceivedPayableIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ReceiverReceivedPayable represents a ReceivedPayable event raised by the Receiver contract. -type ReceiverReceivedPayable struct { - Sender common.Address - Value *big.Int - Str string - Num *big.Int - Flag bool - Raw types.Log // Blockchain specific contextual infos -} - -// FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. -// -// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*ReceiverReceivedPayableIterator, error) { - - logs, sub, err := _Receiver.contract.FilterLogs(opts, "ReceivedPayable") - if err != nil { - return nil, err - } - return &ReceiverReceivedPayableIterator{contract: _Receiver.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil -} - -// WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. -// -// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *ReceiverReceivedPayable) (event.Subscription, error) { - - logs, sub, err := _Receiver.contract.WatchLogs(opts, "ReceivedPayable") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ReceiverReceivedPayable) - if err := _Receiver.contract.UnpackLog(event, "ReceivedPayable", 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 -} - -// ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. -// -// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_Receiver *ReceiverFilterer) ParseReceivedPayable(log types.Log) (*ReceiverReceivedPayable, error) { - event := new(ReceiverReceivedPayable) - if err := _Receiver.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go b/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go index 4517b1c8..5856f803 100644 --- a/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go +++ b/pkg/contracts/prototypes/evm/receiverevm.sol/receiverevm.go @@ -31,8 +31,8 @@ var ( // ReceiverEVMMetaData contains all meta data concerning the ReceiverEVM contract. var ReceiverEVMMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedD\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveA\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveB\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveC\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveD\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"receiveERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"receiveNoParams\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receiveNonPayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"receivePayable\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", } // ReceiverEVMABI is the input ABI used to generate the binding from. @@ -202,93 +202,93 @@ func (_ReceiverEVM *ReceiverEVMTransactorRaw) Transact(opts *bind.TransactOpts, return _ReceiverEVM.Contract.contract.Transact(opts, method, params...) } -// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. // -// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveA(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.contract.Transact(opts, "receiveA", str, num, flag) +// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveERC20(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveERC20", amount, token, destination) } -// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. // -// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_ReceiverEVM *ReceiverEVMSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveA(&_ReceiverEVM.TransactOpts, str, num, flag) +// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() +func (_ReceiverEVM *ReceiverEVMSession) ReceiveERC20(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveERC20(&_ReceiverEVM.TransactOpts, amount, token, destination) } -// ReceiveA is a paid mutator transaction binding the contract method 0x6fa220ad. +// ReceiveERC20 is a paid mutator transaction binding the contract method 0x357fc5a2. // -// Solidity: function receiveA(string str, uint256 num, bool flag) payable returns() -func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveA(str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveA(&_ReceiverEVM.TransactOpts, str, num, flag) +// Solidity: function receiveERC20(uint256 amount, address token, address destination) returns() +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveERC20(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveERC20(&_ReceiverEVM.TransactOpts, amount, token, destination) } -// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. // -// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveB(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.contract.Transact(opts, "receiveB", strs, nums, flag) +// Solidity: function receiveNoParams() returns() +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveNoParams(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveNoParams") } -// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. // -// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_ReceiverEVM *ReceiverEVMSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveB(&_ReceiverEVM.TransactOpts, strs, nums, flag) +// Solidity: function receiveNoParams() returns() +func (_ReceiverEVM *ReceiverEVMSession) ReceiveNoParams() (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveNoParams(&_ReceiverEVM.TransactOpts) } -// ReceiveB is a paid mutator transaction binding the contract method 0xf5db6b39. +// ReceiveNoParams is a paid mutator transaction binding the contract method 0x6ed70169. // -// Solidity: function receiveB(string[] strs, uint256[] nums, bool flag) returns() -func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveB(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveB(&_ReceiverEVM.TransactOpts, strs, nums, flag) +// Solidity: function receiveNoParams() returns() +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveNoParams() (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveNoParams(&_ReceiverEVM.TransactOpts) } -// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. // -// Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveC(opts *bind.TransactOpts, amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _ReceiverEVM.contract.Transact(opts, "receiveC", amount, token, destination) +// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() +func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveNonPayable(opts *bind.TransactOpts, strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receiveNonPayable", strs, nums, flag) } -// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. // -// Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_ReceiverEVM *ReceiverEVMSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveC(&_ReceiverEVM.TransactOpts, amount, token, destination) +// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() +func (_ReceiverEVM *ReceiverEVMSession) ReceiveNonPayable(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveNonPayable(&_ReceiverEVM.TransactOpts, strs, nums, flag) } -// ReceiveC is a paid mutator transaction binding the contract method 0x52df08b6. +// ReceiveNonPayable is a paid mutator transaction binding the contract method 0xf05b6abf. // -// Solidity: function receiveC(uint256 amount, address token, address destination) returns() -func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveC(amount *big.Int, token common.Address, destination common.Address) (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveC(&_ReceiverEVM.TransactOpts, amount, token, destination) +// Solidity: function receiveNonPayable(string[] strs, uint256[] nums, bool flag) returns() +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveNonPayable(strs []string, nums []*big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceiveNonPayable(&_ReceiverEVM.TransactOpts, strs, nums, flag) } -// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. // -// Solidity: function receiveD() returns() -func (_ReceiverEVM *ReceiverEVMTransactor) ReceiveD(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ReceiverEVM.contract.Transact(opts, "receiveD") +// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() +func (_ReceiverEVM *ReceiverEVMTransactor) ReceivePayable(opts *bind.TransactOpts, str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.contract.Transact(opts, "receivePayable", str, num, flag) } -// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. // -// Solidity: function receiveD() returns() -func (_ReceiverEVM *ReceiverEVMSession) ReceiveD() (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveD(&_ReceiverEVM.TransactOpts) +// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() +func (_ReceiverEVM *ReceiverEVMSession) ReceivePayable(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceivePayable(&_ReceiverEVM.TransactOpts, str, num, flag) } -// ReceiveD is a paid mutator transaction binding the contract method 0x86c45192. +// ReceivePayable is a paid mutator transaction binding the contract method 0xe04d4f97. // -// Solidity: function receiveD() returns() -func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceiveD() (*types.Transaction, error) { - return _ReceiverEVM.Contract.ReceiveD(&_ReceiverEVM.TransactOpts) +// Solidity: function receivePayable(string str, uint256 num, bool flag) payable returns() +func (_ReceiverEVM *ReceiverEVMTransactorSession) ReceivePayable(str string, num *big.Int, flag bool) (*types.Transaction, error) { + return _ReceiverEVM.Contract.ReceivePayable(&_ReceiverEVM.TransactOpts, str, num, flag) } -// ReceiverEVMReceivedAIterator is returned from FilterReceivedA and is used to iterate over the raw logs and unpacked data for ReceivedA events raised by the ReceiverEVM contract. -type ReceiverEVMReceivedAIterator struct { - Event *ReceiverEVMReceivedA // Event containing the contract specifics and raw log +// ReceiverEVMReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedERC20Iterator struct { + Event *ReceiverEVMReceivedERC20 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -302,7 +302,7 @@ type ReceiverEVMReceivedAIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverEVMReceivedAIterator) Next() bool { +func (it *ReceiverEVMReceivedERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -311,7 +311,7 @@ func (it *ReceiverEVMReceivedAIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedA) + it.Event = new(ReceiverEVMReceivedERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -326,7 +326,7 @@ func (it *ReceiverEVMReceivedAIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedA) + it.Event = new(ReceiverEVMReceivedERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -342,45 +342,44 @@ func (it *ReceiverEVMReceivedAIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverEVMReceivedAIterator) Error() error { +func (it *ReceiverEVMReceivedERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverEVMReceivedAIterator) Close() error { +func (it *ReceiverEVMReceivedERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverEVMReceivedA represents a ReceivedA event raised by the ReceiverEVM contract. -type ReceiverEVMReceivedA struct { - Sender common.Address - Value *big.Int - Str string - Num *big.Int - Flag bool - Raw types.Log // Blockchain specific contextual infos +// ReceiverEVMReceivedERC20 represents a ReceivedERC20 event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedERC20 struct { + Sender common.Address + Amount *big.Int + Token common.Address + Destination common.Address + Raw types.Log // Blockchain specific contextual infos } -// FilterReceivedA is a free log retrieval operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // -// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedA(opts *bind.FilterOpts) (*ReceiverEVMReceivedAIterator, error) { +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*ReceiverEVMReceivedERC20Iterator, error) { - logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedA") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedERC20") if err != nil { return nil, err } - return &ReceiverEVMReceivedAIterator{contract: _ReceiverEVM.contract, event: "ReceivedA", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedERC20Iterator{contract: _ReceiverEVM.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil } -// WatchReceivedA is a free log subscription operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // -// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedA(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedA) (event.Subscription, error) { +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedERC20) (event.Subscription, error) { - logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedA") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedERC20") if err != nil { return nil, err } @@ -390,8 +389,8 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedA(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverEVMReceivedA) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedA", log); err != nil { + event := new(ReceiverEVMReceivedERC20) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { return err } event.Raw = log @@ -412,21 +411,21 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedA(opts *bind.WatchOpts, si }), nil } -// ParseReceivedA is a log parse operation binding the contract event 0x87d67858b5cc03bdd16a3fcc56773bd59410e946cff7193cf374402c6e8fb6ee. +// ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // -// Solidity: event ReceivedA(address sender, uint256 value, string str, uint256 num, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedA(log types.Log) (*ReceiverEVMReceivedA, error) { - event := new(ReceiverEVMReceivedA) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedA", log); err != nil { +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedERC20(log types.Log) (*ReceiverEVMReceivedERC20, error) { + event := new(ReceiverEVMReceivedERC20) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverEVMReceivedBIterator is returned from FilterReceivedB and is used to iterate over the raw logs and unpacked data for ReceivedB events raised by the ReceiverEVM contract. -type ReceiverEVMReceivedBIterator struct { - Event *ReceiverEVMReceivedB // Event containing the contract specifics and raw log +// ReceiverEVMReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedNoParamsIterator struct { + Event *ReceiverEVMReceivedNoParams // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -440,7 +439,7 @@ type ReceiverEVMReceivedBIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverEVMReceivedBIterator) Next() bool { +func (it *ReceiverEVMReceivedNoParamsIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -449,7 +448,7 @@ func (it *ReceiverEVMReceivedBIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedB) + it.Event = new(ReceiverEVMReceivedNoParams) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -464,7 +463,7 @@ func (it *ReceiverEVMReceivedBIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedB) + it.Event = new(ReceiverEVMReceivedNoParams) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -480,44 +479,41 @@ func (it *ReceiverEVMReceivedBIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverEVMReceivedBIterator) Error() error { +func (it *ReceiverEVMReceivedNoParamsIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverEVMReceivedBIterator) Close() error { +func (it *ReceiverEVMReceivedNoParamsIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverEVMReceivedB represents a ReceivedB event raised by the ReceiverEVM contract. -type ReceiverEVMReceivedB struct { +// ReceiverEVMReceivedNoParams represents a ReceivedNoParams event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedNoParams struct { Sender common.Address - Strs []string - Nums []*big.Int - Flag bool Raw types.Log // Blockchain specific contextual infos } -// FilterReceivedB is a free log retrieval operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // -// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedB(opts *bind.FilterOpts) (*ReceiverEVMReceivedBIterator, error) { +// Solidity: event ReceivedNoParams(address sender) +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*ReceiverEVMReceivedNoParamsIterator, error) { - logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedB") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedNoParams") if err != nil { return nil, err } - return &ReceiverEVMReceivedBIterator{contract: _ReceiverEVM.contract, event: "ReceivedB", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedNoParamsIterator{contract: _ReceiverEVM.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil } -// WatchReceivedB is a free log subscription operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // -// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedB(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedB) (event.Subscription, error) { +// Solidity: event ReceivedNoParams(address sender) +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedNoParams) (event.Subscription, error) { - logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedB") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedNoParams") if err != nil { return nil, err } @@ -527,8 +523,8 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedB(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverEVMReceivedB) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedB", log); err != nil { + event := new(ReceiverEVMReceivedNoParams) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { return err } event.Raw = log @@ -549,21 +545,21 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedB(opts *bind.WatchOpts, si }), nil } -// ParseReceivedB is a log parse operation binding the contract event 0x463b3e5d6969d17b19e10c4ca95f5f1b6fdef8678f980af98071bd38f0d885c2. +// ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // -// Solidity: event ReceivedB(address sender, string[] strs, uint256[] nums, bool flag) -func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedB(log types.Log) (*ReceiverEVMReceivedB, error) { - event := new(ReceiverEVMReceivedB) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedB", log); err != nil { +// Solidity: event ReceivedNoParams(address sender) +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedNoParams(log types.Log) (*ReceiverEVMReceivedNoParams, error) { + event := new(ReceiverEVMReceivedNoParams) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverEVMReceivedCIterator is returned from FilterReceivedC and is used to iterate over the raw logs and unpacked data for ReceivedC events raised by the ReceiverEVM contract. -type ReceiverEVMReceivedCIterator struct { - Event *ReceiverEVMReceivedC // Event containing the contract specifics and raw log +// ReceiverEVMReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedNonPayableIterator struct { + Event *ReceiverEVMReceivedNonPayable // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -577,7 +573,7 @@ type ReceiverEVMReceivedCIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverEVMReceivedCIterator) Next() bool { +func (it *ReceiverEVMReceivedNonPayableIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -586,7 +582,7 @@ func (it *ReceiverEVMReceivedCIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedC) + it.Event = new(ReceiverEVMReceivedNonPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -601,7 +597,7 @@ func (it *ReceiverEVMReceivedCIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedC) + it.Event = new(ReceiverEVMReceivedNonPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -617,44 +613,44 @@ func (it *ReceiverEVMReceivedCIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverEVMReceivedCIterator) Error() error { +func (it *ReceiverEVMReceivedNonPayableIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverEVMReceivedCIterator) Close() error { +func (it *ReceiverEVMReceivedNonPayableIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverEVMReceivedC represents a ReceivedC event raised by the ReceiverEVM contract. -type ReceiverEVMReceivedC struct { - Sender common.Address - Amount *big.Int - Token common.Address - Destination common.Address - Raw types.Log // Blockchain specific contextual infos +// ReceiverEVMReceivedNonPayable represents a ReceivedNonPayable event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedNonPayable struct { + Sender common.Address + Strs []string + Nums []*big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos } -// FilterReceivedC is a free log retrieval operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // -// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedC(opts *bind.FilterOpts) (*ReceiverEVMReceivedCIterator, error) { +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*ReceiverEVMReceivedNonPayableIterator, error) { - logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedC") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedNonPayable") if err != nil { return nil, err } - return &ReceiverEVMReceivedCIterator{contract: _ReceiverEVM.contract, event: "ReceivedC", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedNonPayableIterator{contract: _ReceiverEVM.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil } -// WatchReceivedC is a free log subscription operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // -// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedC(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedC) (event.Subscription, error) { +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedNonPayable) (event.Subscription, error) { - logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedC") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedNonPayable") if err != nil { return nil, err } @@ -664,8 +660,8 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedC(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverEVMReceivedC) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedC", log); err != nil { + event := new(ReceiverEVMReceivedNonPayable) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { return err } event.Raw = log @@ -686,21 +682,21 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedC(opts *bind.WatchOpts, si }), nil } -// ParseReceivedC is a log parse operation binding the contract event 0xe8077791e8d0f63b9e4c0b6d386cbbf6c65e1acb2a103019edba9d1cc0b32900. +// ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // -// Solidity: event ReceivedC(address sender, uint256 amount, address token, address destination) -func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedC(log types.Log) (*ReceiverEVMReceivedC, error) { - event := new(ReceiverEVMReceivedC) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedC", log); err != nil { +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedNonPayable(log types.Log) (*ReceiverEVMReceivedNonPayable, error) { + event := new(ReceiverEVMReceivedNonPayable) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ReceiverEVMReceivedDIterator is returned from FilterReceivedD and is used to iterate over the raw logs and unpacked data for ReceivedD events raised by the ReceiverEVM contract. -type ReceiverEVMReceivedDIterator struct { - Event *ReceiverEVMReceivedD // Event containing the contract specifics and raw log +// ReceiverEVMReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the ReceiverEVM contract. +type ReceiverEVMReceivedPayableIterator struct { + Event *ReceiverEVMReceivedPayable // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -714,7 +710,7 @@ type ReceiverEVMReceivedDIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ReceiverEVMReceivedDIterator) Next() bool { +func (it *ReceiverEVMReceivedPayableIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -723,7 +719,7 @@ func (it *ReceiverEVMReceivedDIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedD) + it.Event = new(ReceiverEVMReceivedPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -738,7 +734,7 @@ func (it *ReceiverEVMReceivedDIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ReceiverEVMReceivedD) + it.Event = new(ReceiverEVMReceivedPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -754,41 +750,45 @@ func (it *ReceiverEVMReceivedDIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ReceiverEVMReceivedDIterator) Error() error { +func (it *ReceiverEVMReceivedPayableIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ReceiverEVMReceivedDIterator) Close() error { +func (it *ReceiverEVMReceivedPayableIterator) Close() error { it.sub.Unsubscribe() return nil } -// ReceiverEVMReceivedD represents a ReceivedD event raised by the ReceiverEVM contract. -type ReceiverEVMReceivedD struct { +// ReceiverEVMReceivedPayable represents a ReceivedPayable event raised by the ReceiverEVM contract. +type ReceiverEVMReceivedPayable struct { Sender common.Address + Value *big.Int + Str string + Num *big.Int + Flag bool Raw types.Log // Blockchain specific contextual infos } -// FilterReceivedD is a free log retrieval operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // -// Solidity: event ReceivedD(address sender) -func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedD(opts *bind.FilterOpts) (*ReceiverEVMReceivedDIterator, error) { +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*ReceiverEVMReceivedPayableIterator, error) { - logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedD") + logs, sub, err := _ReceiverEVM.contract.FilterLogs(opts, "ReceivedPayable") if err != nil { return nil, err } - return &ReceiverEVMReceivedDIterator{contract: _ReceiverEVM.contract, event: "ReceivedD", logs: logs, sub: sub}, nil + return &ReceiverEVMReceivedPayableIterator{contract: _ReceiverEVM.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil } -// WatchReceivedD is a free log subscription operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // -// Solidity: event ReceivedD(address sender) -func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedD(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedD) (event.Subscription, error) { +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *ReceiverEVMReceivedPayable) (event.Subscription, error) { - logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedD") + logs, sub, err := _ReceiverEVM.contract.WatchLogs(opts, "ReceivedPayable") if err != nil { return nil, err } @@ -798,8 +798,8 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedD(opts *bind.WatchOpts, si select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ReceiverEVMReceivedD) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedD", log); err != nil { + event := new(ReceiverEVMReceivedPayable) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { return err } event.Raw = log @@ -820,12 +820,12 @@ func (_ReceiverEVM *ReceiverEVMFilterer) WatchReceivedD(opts *bind.WatchOpts, si }), nil } -// ParseReceivedD is a log parse operation binding the contract event 0xcf0e6f18d967cb5a3ca7781d74b1d66411d1b8984e2dd2a066709c204a66d862. +// ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // -// Solidity: event ReceivedD(address sender) -func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedD(log types.Log) (*ReceiverEVMReceivedD, error) { - event := new(ReceiverEVMReceivedD) - if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedD", log); err != nil { +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_ReceiverEVM *ReceiverEVMFilterer) ParseReceivedPayable(log types.Log) (*ReceiverEVMReceivedPayable, error) { + event := new(ReceiverEVMReceivedPayable) + if err := _ReceiverEVM.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { return nil, err } event.Raw = log diff --git a/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts b/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts index a1d97ed8..1608a7a7 100644 --- a/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts +++ b/typechain-types/contracts/prototypes/evm/ReceiverEVM.ts @@ -30,26 +30,34 @@ import type { export interface ReceiverEVMInterface extends utils.Interface { functions: { - "receiveA(string,uint256,bool)": FunctionFragment; - "receiveB(string[],uint256[],bool)": FunctionFragment; - "receiveC(uint256,address,address)": FunctionFragment; - "receiveD()": FunctionFragment; + "receiveERC20(uint256,address,address)": FunctionFragment; + "receiveNoParams()": FunctionFragment; + "receiveNonPayable(string[],uint256[],bool)": FunctionFragment; + "receivePayable(string,uint256,bool)": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: "receiveA" | "receiveB" | "receiveC" | "receiveD" + nameOrSignatureOrTopic: + | "receiveERC20" + | "receiveNoParams" + | "receiveNonPayable" + | "receivePayable" ): FunctionFragment; encodeFunctionData( - functionFragment: "receiveA", + functionFragment: "receiveERC20", values: [ - PromiseOrValue, PromiseOrValue, - PromiseOrValue + PromiseOrValue, + PromiseOrValue ] ): string; encodeFunctionData( - functionFragment: "receiveB", + functionFragment: "receiveNoParams", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "receiveNonPayable", values: [ PromiseOrValue[], PromiseOrValue[], @@ -57,79 +65,95 @@ export interface ReceiverEVMInterface extends utils.Interface { ] ): string; encodeFunctionData( - functionFragment: "receiveC", + functionFragment: "receivePayable", values: [ - PromiseOrValue, PromiseOrValue, - PromiseOrValue + PromiseOrValue, + PromiseOrValue ] ): string; - encodeFunctionData(functionFragment: "receiveD", values?: undefined): string; - decodeFunctionResult(functionFragment: "receiveA", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "receiveB", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "receiveC", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "receiveD", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "receiveERC20", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "receiveNoParams", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "receiveNonPayable", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "receivePayable", + data: BytesLike + ): Result; events: { - "ReceivedA(address,uint256,string,uint256,bool)": EventFragment; - "ReceivedB(address,string[],uint256[],bool)": EventFragment; - "ReceivedC(address,uint256,address,address)": EventFragment; - "ReceivedD(address)": EventFragment; + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; }; - getEvent(nameOrSignatureOrTopic: "ReceivedA"): EventFragment; - getEvent(nameOrSignatureOrTopic: "ReceivedB"): EventFragment; - getEvent(nameOrSignatureOrTopic: "ReceivedC"): EventFragment; - getEvent(nameOrSignatureOrTopic: "ReceivedD"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; } -export interface ReceivedAEventObject { +export interface ReceivedERC20EventObject { sender: string; - value: BigNumber; - str: string; - num: BigNumber; - flag: boolean; + amount: BigNumber; + token: string; + destination: string; } -export type ReceivedAEvent = TypedEvent< - [string, BigNumber, string, BigNumber, boolean], - ReceivedAEventObject +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject >; -export type ReceivedAEventFilter = TypedEventFilter; +export type ReceivedERC20EventFilter = TypedEventFilter; -export interface ReceivedBEventObject { +export interface ReceivedNoParamsEventObject { sender: string; - strs: string[]; - nums: BigNumber[]; - flag: boolean; } -export type ReceivedBEvent = TypedEvent< - [string, string[], BigNumber[], boolean], - ReceivedBEventObject +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject >; -export type ReceivedBEventFilter = TypedEventFilter; +export type ReceivedNoParamsEventFilter = + TypedEventFilter; -export interface ReceivedCEventObject { +export interface ReceivedNonPayableEventObject { sender: string; - amount: BigNumber; - token: string; - destination: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; } -export type ReceivedCEvent = TypedEvent< - [string, BigNumber, string, string], - ReceivedCEventObject +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject >; -export type ReceivedCEventFilter = TypedEventFilter; +export type ReceivedNonPayableEventFilter = + TypedEventFilter; -export interface ReceivedDEventObject { +export interface ReceivedPayableEventObject { sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; } -export type ReceivedDEvent = TypedEvent<[string], ReceivedDEventObject>; +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; -export type ReceivedDEventFilter = TypedEventFilter; +export type ReceivedPayableEventFilter = TypedEventFilter; export interface ReceiverEVM extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; @@ -158,179 +182,179 @@ export interface ReceiverEVM extends BaseContract { removeListener: OnEvent; functions: { - receiveA( - str: PromiseOrValue, - num: PromiseOrValue, - flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + receiveERC20( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveB( - strs: PromiseOrValue[], - nums: PromiseOrValue[], - flag: PromiseOrValue, + receiveNoParams( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveC( - amount: PromiseOrValue, - token: PromiseOrValue, - destination: PromiseOrValue, + receiveNonPayable( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveD( - overrides?: Overrides & { from?: PromiseOrValue } + receivePayable( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; }; - receiveA( - str: PromiseOrValue, - num: PromiseOrValue, - flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + receiveERC20( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveB( - strs: PromiseOrValue[], - nums: PromiseOrValue[], - flag: PromiseOrValue, + receiveNoParams( overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveC( - amount: PromiseOrValue, - token: PromiseOrValue, - destination: PromiseOrValue, + receiveNonPayable( + strs: PromiseOrValue[], + nums: PromiseOrValue[], + flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveD( - overrides?: Overrides & { from?: PromiseOrValue } + receivePayable( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; callStatic: { - receiveA( - str: PromiseOrValue, - num: PromiseOrValue, - flag: PromiseOrValue, + receiveERC20( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, overrides?: CallOverrides ): Promise; - receiveB( + receiveNoParams(overrides?: CallOverrides): Promise; + + receiveNonPayable( strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, overrides?: CallOverrides ): Promise; - receiveC( - amount: PromiseOrValue, - token: PromiseOrValue, - destination: PromiseOrValue, + receivePayable( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, overrides?: CallOverrides ): Promise; - - receiveD(overrides?: CallOverrides): Promise; }; filters: { - "ReceivedA(address,uint256,string,uint256,bool)"( + "ReceivedERC20(address,uint256,address,address)"( sender?: null, - value?: null, - str?: null, - num?: null, - flag?: null - ): ReceivedAEventFilter; - ReceivedA( + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( sender?: null, - value?: null, - str?: null, - num?: null, - flag?: null - ): ReceivedAEventFilter; + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; - "ReceivedB(address,string[],uint256[],bool)"( + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( sender?: null, strs?: null, nums?: null, flag?: null - ): ReceivedBEventFilter; - ReceivedB( + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( sender?: null, strs?: null, nums?: null, flag?: null - ): ReceivedBEventFilter; + ): ReceivedNonPayableEventFilter; - "ReceivedC(address,uint256,address,address)"( + "ReceivedPayable(address,uint256,string,uint256,bool)"( sender?: null, - amount?: null, - token?: null, - destination?: null - ): ReceivedCEventFilter; - ReceivedC( + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( sender?: null, - amount?: null, - token?: null, - destination?: null - ): ReceivedCEventFilter; - - "ReceivedD(address)"(sender?: null): ReceivedDEventFilter; - ReceivedD(sender?: null): ReceivedDEventFilter; + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; }; estimateGas: { - receiveA( - str: PromiseOrValue, - num: PromiseOrValue, - flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } + receiveERC20( + amount: PromiseOrValue, + token: PromiseOrValue, + destination: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveB( + receiveNoParams( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + receiveNonPayable( strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveC( + receivePayable( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + receiveERC20( amount: PromiseOrValue, token: PromiseOrValue, destination: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; + ): Promise; - receiveD( + receiveNoParams( overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - }; - - populateTransaction: { - receiveA( - str: PromiseOrValue, - num: PromiseOrValue, - flag: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - receiveB( + receiveNonPayable( strs: PromiseOrValue[], nums: PromiseOrValue[], flag: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - receiveC( - amount: PromiseOrValue, - token: PromiseOrValue, - destination: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - receiveD( - overrides?: Overrides & { from?: PromiseOrValue } + receivePayable( + str: PromiseOrValue, + num: PromiseOrValue, + flag: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index c93722c3..939b9af8 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -6,6 +6,5 @@ export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { GatewayEVM } from "./GatewayEVM"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; -export type { Receiver } from "./Receiver"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts index b290f45e..cda804bb 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ReceiverEVM__factory.ts @@ -22,29 +22,36 @@ const _abi = [ { indexed: false, internalType: "uint256", - name: "value", + name: "amount", type: "uint256", }, { indexed: false, - internalType: "string", - name: "str", - type: "string", + internalType: "address", + name: "token", + type: "address", }, { indexed: false, - internalType: "uint256", - name: "num", - type: "uint256", + internalType: "address", + name: "destination", + type: "address", }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ { indexed: false, - internalType: "bool", - name: "flag", - type: "bool", + internalType: "address", + name: "sender", + type: "address", }, ], - name: "ReceivedA", + name: "ReceivedNoParams", type: "event", }, { @@ -75,7 +82,7 @@ const _abi = [ type: "bool", }, ], - name: "ReceivedB", + name: "ReceivedNonPayable", type: "event", }, { @@ -90,59 +97,59 @@ const _abi = [ { indexed: false, internalType: "uint256", - name: "amount", + name: "value", type: "uint256", }, { indexed: false, - internalType: "address", - name: "token", - type: "address", + internalType: "string", + name: "str", + type: "string", }, { indexed: false, - internalType: "address", - name: "destination", - type: "address", + internalType: "uint256", + name: "num", + type: "uint256", }, - ], - name: "ReceivedC", - type: "event", - }, - { - anonymous: false, - inputs: [ { indexed: false, - internalType: "address", - name: "sender", - type: "address", + internalType: "bool", + name: "flag", + type: "bool", }, ], - name: "ReceivedD", + name: "ReceivedPayable", type: "event", }, { inputs: [ - { - internalType: "string", - name: "str", - type: "string", - }, { internalType: "uint256", - name: "num", + name: "amount", type: "uint256", }, { - internalType: "bool", - name: "flag", - type: "bool", + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "destination", + type: "address", }, ], - name: "receiveA", + name: "receiveERC20", outputs: [], - stateMutability: "payable", + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "receiveNoParams", + outputs: [], + stateMutability: "nonpayable", type: "function", }, { @@ -163,7 +170,7 @@ const _abi = [ type: "bool", }, ], - name: "receiveB", + name: "receiveNonPayable", outputs: [], stateMutability: "nonpayable", type: "function", @@ -171,37 +178,30 @@ const _abi = [ { inputs: [ { - internalType: "uint256", - name: "amount", - type: "uint256", + internalType: "string", + name: "str", + type: "string", }, { - internalType: "address", - name: "token", - type: "address", + internalType: "uint256", + name: "num", + type: "uint256", }, { - internalType: "address", - name: "destination", - type: "address", + internalType: "bool", + name: "flag", + type: "bool", }, ], - name: "receiveC", + name: "receivePayable", outputs: [], - stateMutability: "nonpayable", - type: "function", - }, - { - inputs: [], - name: "receiveD", - outputs: [], - stateMutability: "nonpayable", + stateMutability: "payable", type: "function", }, ] as const; const _bytecode = - "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"; + "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"; type ReceiverEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index 37fd9398..b7a35400 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -5,6 +5,5 @@ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; -export { Receiver__factory } from "./Receiver__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index af2fea6a..9ab48b37 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -348,10 +348,6 @@ declare module "hardhat/types/runtime" { name: "IGatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "Receiver", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "ReceiverEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -877,11 +873,6 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "Receiver", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "ReceiverEVM", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index fac01f21..324af66f 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -164,8 +164,6 @@ export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEV export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory"; -export type { Receiver } from "./contracts/prototypes/evm/Receiver"; -export { Receiver__factory } from "./factories/contracts/prototypes/evm/Receiver__factory"; export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; From cc93e3efce763553af3bbb12736a94f50402e288 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 17:37:04 +0200 Subject: [PATCH 38/86] fixes after merge --- contracts/prototypes/zevm/Sender.sol | 36 --- contracts/prototypes/zevm/SenderZEVM.sol | 8 +- package.json | 4 +- .../prototypes/zevm/sender.sol/sender.go | 276 ------------------ .../zevm/senderzevm.sol/senderzevm.go | 2 +- .../contracts/prototypes/zevm/index.ts | 1 - .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../contracts/prototypes/zevm/index.ts | 1 - typechain-types/hardhat.d.ts | 9 - typechain-types/index.ts | 2 - 10 files changed, 8 insertions(+), 333 deletions(-) delete mode 100644 contracts/prototypes/zevm/Sender.sol delete mode 100644 pkg/contracts/prototypes/zevm/sender.sol/sender.go diff --git a/contracts/prototypes/zevm/Sender.sol b/contracts/prototypes/zevm/Sender.sol deleted file mode 100644 index a39831e3..00000000 --- a/contracts/prototypes/zevm/Sender.sol +++ /dev/null @@ -1,36 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.7; - -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./interfaces.sol"; -import "../../zevm/interfaces/IZRC20.sol"; - -contract Sender { - address public gateway; - error ApprovalFailed(); - - constructor(address _gateway) { - gateway = _gateway; - } - - // Call receiver on EVM - function callReceiver(bytes memory receiver, string memory str, uint256 num, bool flag) external { - // Encode the function call to the receiver's receivePayable method - bytes memory message = abi.encodeWithSignature("receivePayable(string,uint256,bool)", str, num, flag); - - // Pass encoded call to gateway - IGatewayZEVM(gateway).call(receiver, message); - } - - // Withdraw and call receiver on EVM - function withdrawAndCallReceiver(bytes memory receiver, uint256 amount, address zrc20, string memory str, uint256 num, bool flag) external { - // Encode the function call to the receiver's receivePayable method - bytes memory message = abi.encodeWithSignature("receivePayable(string,uint256,bool)", str, num, flag); - - // Approve gateway to withdraw - if(!IZRC20(zrc20).approve(gateway, amount)) revert ApprovalFailed(); - - // Pass encoded call to gateway - IGatewayZEVM(gateway).withdrawAndCall(receiver, amount, zrc20, message); - } -} \ No newline at end of file diff --git a/contracts/prototypes/zevm/SenderZEVM.sol b/contracts/prototypes/zevm/SenderZEVM.sol index 003bffec..711d1d97 100644 --- a/contracts/prototypes/zevm/SenderZEVM.sol +++ b/contracts/prototypes/zevm/SenderZEVM.sol @@ -15,8 +15,8 @@ contract SenderZEVM { // Call receiver on EVM function callReceiver(bytes memory receiver, string memory str, uint256 num, bool flag) external { - // Encode the function call to the receiver's receiveA method - bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); + // Encode the function call to the receiver's receivePayable method + bytes memory message = abi.encodeWithSignature("receivePayable(string,uint256,bool)", str, num, flag); // Pass encoded call to gateway IGatewayZEVM(gateway).call(receiver, message); @@ -24,8 +24,8 @@ contract SenderZEVM { // Withdraw and call receiver on EVM function withdrawAndCallReceiver(bytes memory receiver, uint256 amount, address zrc20, string memory str, uint256 num, bool flag) external { - // Encode the function call to the receiver's receiveA method - bytes memory message = abi.encodeWithSignature("receiveA(string,uint256,bool)", str, num, flag); + // Encode the function call to the receiver's receivePayable method + bytes memory message = abi.encodeWithSignature("receivePayable(string,uint256,bool)", str, num, flag); // Approve gateway to withdraw if(!IZRC20(zrc20).approve(gateway, amount)) revert ApprovalFailed(); diff --git a/package.json b/package.json index 8b33db5c..f392d2eb 100644 --- a/package.json +++ b/package.json @@ -84,12 +84,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", + "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", - "worker": "npx hardhat run scripts/worker.ts --network localhost", - "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"" + "worker": "npx hardhat run scripts/worker.ts --network localhost" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/pkg/contracts/prototypes/zevm/sender.sol/sender.go b/pkg/contracts/prototypes/zevm/sender.sol/sender.go deleted file mode 100644 index 3f0bd6f4..00000000 --- a/pkg/contracts/prototypes/zevm/sender.sol/sender.go +++ /dev/null @@ -1,276 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package sender - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// SenderMetaData contains all meta data concerning the Sender contract. -var SenderMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", -} - -// SenderABI is the input ABI used to generate the binding from. -// Deprecated: Use SenderMetaData.ABI instead. -var SenderABI = SenderMetaData.ABI - -// SenderBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use SenderMetaData.Bin instead. -var SenderBin = SenderMetaData.Bin - -// DeploySender deploys a new Ethereum contract, binding an instance of Sender to it. -func DeploySender(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address) (common.Address, *types.Transaction, *Sender, error) { - parsed, err := SenderMetaData.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(SenderBin), backend, _gateway) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil -} - -// Sender is an auto generated Go binding around an Ethereum contract. -type Sender struct { - SenderCaller // Read-only binding to the contract - SenderTransactor // Write-only binding to the contract - SenderFilterer // Log filterer for contract events -} - -// SenderCaller is an auto generated read-only Go binding around an Ethereum contract. -type SenderCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// SenderTransactor is an auto generated write-only Go binding around an Ethereum contract. -type SenderTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// SenderFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type SenderFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// SenderSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type SenderSession struct { - Contract *Sender // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// SenderCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type SenderCallerSession struct { - Contract *SenderCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// SenderTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type SenderTransactorSession struct { - Contract *SenderTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// SenderRaw is an auto generated low-level Go binding around an Ethereum contract. -type SenderRaw struct { - Contract *Sender // Generic contract binding to access the raw methods on -} - -// SenderCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type SenderCallerRaw struct { - Contract *SenderCaller // Generic read-only contract binding to access the raw methods on -} - -// SenderTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type SenderTransactorRaw struct { - Contract *SenderTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewSender creates a new instance of Sender, bound to a specific deployed contract. -func NewSender(address common.Address, backend bind.ContractBackend) (*Sender, error) { - contract, err := bindSender(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &Sender{SenderCaller: SenderCaller{contract: contract}, SenderTransactor: SenderTransactor{contract: contract}, SenderFilterer: SenderFilterer{contract: contract}}, nil -} - -// NewSenderCaller creates a new read-only instance of Sender, bound to a specific deployed contract. -func NewSenderCaller(address common.Address, caller bind.ContractCaller) (*SenderCaller, error) { - contract, err := bindSender(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &SenderCaller{contract: contract}, nil -} - -// NewSenderTransactor creates a new write-only instance of Sender, bound to a specific deployed contract. -func NewSenderTransactor(address common.Address, transactor bind.ContractTransactor) (*SenderTransactor, error) { - contract, err := bindSender(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &SenderTransactor{contract: contract}, nil -} - -// NewSenderFilterer creates a new log filterer instance of Sender, bound to a specific deployed contract. -func NewSenderFilterer(address common.Address, filterer bind.ContractFilterer) (*SenderFilterer, error) { - contract, err := bindSender(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &SenderFilterer{contract: contract}, nil -} - -// bindSender binds a generic wrapper to an already deployed contract. -func bindSender(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := SenderMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Sender *SenderRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Sender.Contract.SenderCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Sender *SenderRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Sender.Contract.SenderTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Sender *SenderRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Sender.Contract.SenderTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_Sender *SenderCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _Sender.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_Sender *SenderTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _Sender.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_Sender *SenderTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _Sender.Contract.contract.Transact(opts, method, params...) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_Sender *SenderCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _Sender.contract.Call(opts, &out, "gateway") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_Sender *SenderSession) Gateway() (common.Address, error) { - return _Sender.Contract.Gateway(&_Sender.CallOpts) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_Sender *SenderCallerSession) Gateway() (common.Address, error) { - return _Sender.Contract.Gateway(&_Sender.CallOpts) -} - -// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. -// -// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactor) CallReceiver(opts *bind.TransactOpts, receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.contract.Transact(opts, "callReceiver", receiver, str, num, flag) -} - -// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. -// -// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) -} - -// CallReceiver is a paid mutator transaction binding the contract method 0xa0a1730b. -// -// Solidity: function callReceiver(bytes receiver, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactorSession) CallReceiver(receiver []byte, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.CallReceiver(&_Sender.TransactOpts, receiver, str, num, flag) -} - -// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. -// -// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactor) WithdrawAndCallReceiver(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.contract.Transact(opts, "withdrawAndCallReceiver", receiver, amount, zrc20, str, num, flag) -} - -// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. -// -// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) -} - -// WithdrawAndCallReceiver is a paid mutator transaction binding the contract method 0x0abd8905. -// -// Solidity: function withdrawAndCallReceiver(bytes receiver, uint256 amount, address zrc20, string str, uint256 num, bool flag) returns() -func (_Sender *SenderTransactorSession) WithdrawAndCallReceiver(receiver []byte, amount *big.Int, zrc20 common.Address, str string, num *big.Int, flag bool) (*types.Transaction, error) { - return _Sender.Contract.WithdrawAndCallReceiver(&_Sender.TransactOpts, receiver, amount, zrc20, str, num, flag) -} diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index bdacbc90..77c21d44 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts index 9039d994..e6090cc6 100644 --- a/typechain-types/contracts/prototypes/zevm/index.ts +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -6,6 +6,5 @@ export type { zrc20NewSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { GatewayZEVM } from "./GatewayZEVM"; -export type { Sender } from "./Sender"; export type { SenderZEVM } from "./SenderZEVM"; export type { TestZContract } from "./TestZContract"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index 154c7ad8..fafcf4e0 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts index 9090a934..389b7ace 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -4,6 +4,5 @@ export * as zrc20NewSol from "./ZRC20New.sol"; export * as interfacesSol from "./interfaces.sol"; export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; -export { Sender__factory } from "./Sender__factory"; export { SenderZEVM__factory } from "./SenderZEVM__factory"; export { TestZContract__factory } from "./TestZContract__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 9ab48b37..6f78440d 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -364,10 +364,6 @@ declare module "hardhat/types/runtime" { name: "IGatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "Sender", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "SenderZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -893,11 +889,6 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "Sender", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "SenderZEVM", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 324af66f..f17533ca 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -172,8 +172,6 @@ export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; -export type { Sender } from "./contracts/prototypes/zevm/Sender"; -export { Sender__factory } from "./factories/contracts/prototypes/zevm/Sender__factory"; export type { SenderZEVM } from "./contracts/prototypes/zevm/SenderZEVM"; export { SenderZEVM__factory } from "./factories/contracts/prototypes/zevm/SenderZEVM__factory"; export type { TestZContract } from "./contracts/prototypes/zevm/TestZContract"; From 5a5f76b6527f9902608dd86436afa7065b84d3db Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 17:43:55 +0200 Subject: [PATCH 39/86] fix tests --- test/prototypes/GatewayIntegration.spec.ts | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 61909386..998c63bc 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -102,7 +102,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); }); - it("should call Receiver contract on EVM from ZEVM account", async function () { + it("should call ReceiverEVM from ZEVM account", async function () { const str = "Hello, Hardhat!"; const num = 42; const flag = true; @@ -110,8 +110,10 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); - const callTx = await gatewayZEVM.connect(ownerZEVM).call(ethers.utils.arrayify(addrs[0].address), message); - await expect(callTx).to.emit(gatewayZEVM, "Call").withArgs(ownerZEVM.address, addrs[0].address, message); + const callTx = await gatewayZEVM.connect(ownerZEVM).call(receiverEVM.address, message); + await expect(callTx) + .to.emit(gatewayZEVM, "Call") + .withArgs(ownerZEVM.address, receiverEVM.address.toLowerCase(), message); // Get message from events const callTxReceipt = await callTx.wait(); @@ -126,7 +128,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { await expect(executeTx).to.emit(receiverEVM, "ReceivedPayable").withArgs(gatewayEVM.address, value, str, num, flag); }); - it("should withdraw and call Receiver contract on EVM from ZEVM account", async function () { + it("should withdraw and call ReceiverEVM from ZEVM account", async function () { const str = "Hello, Hardhat!"; const num = 42; const flag = true; @@ -165,7 +167,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); }); - it("should call Receiver contract on EVM from Sender contract on ZEVM", async function () { + it("should call ReceiverEVM from SenderZEVM", async function () { const str = "Hello, Hardhat!"; const num = 42; const flag = true; @@ -179,7 +181,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { const expectedMessage = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); await expect(callTx) .to.emit(gatewayZEVM, "Call") - .withArgs(senderZEVM.address, receiverEVM.address, expectedMessage); + .withArgs(senderZEVM.address, receiverEVM.address.toLowerCase(), expectedMessage); const callEvent = callTxReceipt.events[0]; const callMessage = callEvent.args[2]; @@ -192,7 +194,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { await expect(executeTx).to.emit(receiverEVM, "ReceivedPayable").withArgs(gatewayEVM.address, value, str, num, flag); }); - it("should withdrawn and call Receiver contract on EVM from Sender contract on ZEVM", async function () { + it("should withdrawn and call ReceiverEVM from SenderZEVM", async function () { const str = "Hello, Hardhat!"; const num = 42; const flag = true; From 941949ecb8f3e5cbabfbae4b294daf317b8ec342 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 17:58:23 +0200 Subject: [PATCH 40/86] fix worker after merge --- scripts/worker.ts | 4 ++-- tasks/localnet.ts | 6 +++--- yarn.lock | 2 +- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/scripts/worker.ts b/scripts/worker.ts index ad22dc7c..4d7fb025 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -129,8 +129,8 @@ export const startWorker = async () => { await executeTx.wait(); }); - receiverEVM.on("ReceivedA", () => { - console.log("ReceiverEVM: receiveA called!"); + receiverEVM.on("ReceivedPayable", () => { + console.log("ReceiverEVM: receivePayable called!"); }); gatewayEVM.on("Call", async (...args: Array) => { diff --git a/tasks/localnet.ts b/tasks/localnet.ts index 410987b3..fe2495f8 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -6,7 +6,7 @@ declare const hre: any; // To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses // Otherwise, provide custom addresses as parameters -task("call-evm-receiver", "calls evm receiver from zevm account") +task("call-evm", "calls evm contract from zevm account") .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") .setAction(async (taskArgs) => { @@ -18,14 +18,14 @@ task("call-evm-receiver", "calls evm receiver from zevm account") const flag = true; // Encode the function call data and call on zevm - const message = receiverEVM.interface.encodeFunctionData("receiveA", [str, num, flag]); + const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); const callTx = await gatewayZEVM.call(receiverEVM.address, message); await callTx.wait(); console.log("ReceiverEVM called from ZEVM"); }); -task("call-zevm-zcontract", "calls zevm zcontract from evm account") +task("call-zevm", "calls zevm zcontract from evm account") .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") .setAction(async (taskArgs) => { diff --git a/yarn.lock b/yarn.lock index 2f9ee3a0..2d84082a 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2274,7 +2274,7 @@ "@uniswap/v3-core" "1.0.0" base64-sol "1.0.1" -"@zetachain/networks@8.0.0": +"@zetachain/networks@^8.0.0": version "8.0.0" resolved "https://registry.yarnpkg.com/@zetachain/networks/-/networks-8.0.0.tgz#3e838bb6b14e4a8d381f95b4cbc2f1172e851e4e" integrity sha512-I0HhH5qOGW0Jkjq5o5Mi6qGls6ycHnhWjc+r+Ud8u8YW+HU4lEUn4gvulxj+ccHKj3nV/0gEsmNrWRY9ct49nQ== From 627528298580002846dd559e2b26421d153fb948 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 18:58:18 +0200 Subject: [PATCH 41/86] add more tasks --- hardhat.config.ts | 5 +++++ scripts/worker.ts | 48 ++++++++++++++++++++++++++++++++++++++---- tasks/localnet.ts | 53 +++++++++++++++++++++++++++++++++++++++++++++-- 3 files changed, 100 insertions(+), 6 deletions(-) diff --git a/hardhat.config.ts b/hardhat.config.ts index 8fdc1844..d58755a4 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -43,6 +43,11 @@ const config: HardhatUserConfig = { }, networks: { ...getHardhatConfigNetworks(), + localhost: { + gas: 30_000_000, + gasLimit: 30_000_000, + url: "http://localhost:8545", + }, }, solidity: { compilers: [ diff --git a/scripts/worker.ts b/scripts/worker.ts index 4d7fb025..78c25d17 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -10,7 +10,7 @@ const hre = require("hardhat"); export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; export const startWorker = async () => { - console.log("deploying contracts"); + console.log("worker starting"); // EVM let receiverEVM: Contract; let gatewayEVM: Contract; @@ -122,32 +122,72 @@ export const startWorker = async () => { await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); + // event Call(address indexed sender, bytes receiver, bytes message); gatewayZEVM.on("Call", async (...args: Array) => { console.log("Worker: Call event on GatewayZEVM."); console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); - const executeTx = await gatewayEVM.execute(args[1], args[2], { value: 0 }); + const receiver = args[1]; + const message = args[2]; + const executeTx = await gatewayEVM.execute(receiver, message, { value: 0 }); await executeTx.wait(); }); + // event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); + gatewayZEVM.on("Withdrawal", async (...args: Array) => { + console.log("Worker: Withdrawal event on GatewayZEVM."); + const receiver = args[1]; + const message = args[5]; + if (args[5] != "0x") { + console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); + const executeTx = await gatewayEVM.execute(receiver, message, { value: 0 }); + await executeTx.wait(); + } + }); + receiverEVM.on("ReceivedPayable", () => { console.log("ReceiverEVM: receivePayable called!"); }); + // event Call(address indexed sender, address indexed receiver, bytes payload); gatewayEVM.on("Call", async (...args: Array) => { console.log("Worker: Call event on GatewayEVM."); console.log("Worker: Calling TestZContract through GatewayZEVM..."); + const zContract = args[1]; + const payload = args[2] const executeTx = await gatewayZEVM .connect(fungibleModuleSigner) .execute( [gatewayZEVM.address, fungibleModuleSigner.address, 1], + // onCrosschainCall contains zrc20 and amount which is not available in Call event ZRC20Contract.address, parseEther("0"), - testZContract.address, - args[2] + zContract, + payload, ); await executeTx.wait(); }); + // event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); + gatewayEVM.on("Deposit", async (...args: Array) => { + console.log("Worker: Deposit event on GatewayEVM."); + const receiver = args[1]; + const asset = args[3]; + const payload = args[4]; + if (args[4] != "0x") { + console.log("Worker: Calling TestZContract through GatewayZEVM..."); + const executeTx = await gatewayZEVM + .connect(fungibleModuleSigner) + .execute( + [gatewayZEVM.address, fungibleModuleSigner.address, 1], + asset, + parseEther("0"), + receiver, + payload, + ); + await executeTx.wait(); + } + }); + testZContract.on("ContextData", async () => { console.log("TestZContract: onCrosschainCall called!"); }); diff --git a/tasks/localnet.ts b/tasks/localnet.ts index fe2495f8..1f864d10 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -6,7 +6,7 @@ declare const hre: any; // To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses // Otherwise, provide custom addresses as parameters -task("call-evm", "calls evm contract from zevm account") +task("zevm-call", "calls evm contract from zevm account") .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") .setAction(async (taskArgs) => { @@ -20,12 +20,37 @@ task("call-evm", "calls evm contract from zevm account") // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); const callTx = await gatewayZEVM.call(receiverEVM.address, message); + await callTx.wait(); + + console.log("ReceiverEVM called from ZEVM"); + }); +task("zevm-withdraw-and-call", "withdraws zrc20 and calls evm contract from zevm account") + .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") + .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") + .addOptionalParam("zrc20", "contract address of zrc20", "0x9fd96203f7b22bCF72d9DCb40ff98302376cE09c") + .addOptionalParam("amount", "amount to withdraw", "1") + .setAction(async (taskArgs) => { + const gatewayZEVM = await hre.ethers.getContractAt("GatewayZEVM", taskArgs.gatewayZEVM); + const receiverEVM = await hre.ethers.getContractAt("ReceiverEVM", taskArgs.receiverEVM); + const zrc20 = await hre.ethers.getContractAt("ZRC20New", taskArgs.zrc20); + const [, ownerZEVM] = await hre.ethers.getSigners(); + + const str = "Hello!"; + const num = 42; + const flag = true; + + // Encode the function call data and call on zevm + const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); + const callTx = await gatewayZEVM + .connect(ownerZEVM) + .withdrawAndCall(receiverEVM.address, hre.ethers.utils.parseEther(taskArgs.amount), zrc20.address, message); await callTx.wait(); + console.log("ReceiverEVM called from ZEVM"); }); -task("call-zevm", "calls zevm zcontract from evm account") +task("evm-call", "calls zevm zcontract from evm account") .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") .setAction(async (taskArgs) => { @@ -34,7 +59,31 @@ task("call-zevm", "calls zevm zcontract from evm account") const message = hre.ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); const callTx = await gatewayEVM.call(zContract.address, message); + await callTx.wait(); + + console.log("TestZContract called from EVM"); + }); + +task("evm-deposit-and-call", "deposits erc20 and calls zevm zcontract from evm account") + .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") + .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") + .addOptionalParam("erc20", "contract address of erc20", "0xddE78e6202518FF4936b5302cC2891ec180E8bFf") + .addOptionalParam("amount", "amount to deposit", "1") + .setAction(async (taskArgs) => { + const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", taskArgs.gatewayEVM); + const zContract = await hre.ethers.getContractAt("TestZContract", taskArgs.zContract); + const erc20 = await hre.ethers.getContractAt("TestERC20", taskArgs.erc20); + + await erc20.approve(gatewayEVM.address, hre.ethers.utils.parseEther(taskArgs.amount)); + const payload = hre.ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); + const callTx = await gatewayEVM["depositAndCall(address,uint256,address,bytes)"]( + zContract.address, + hre.ethers.utils.parseEther(taskArgs.amount), + erc20.address, + payload + ); await callTx.wait(); + console.log("TestZContract called from EVM"); }); From 8c33743bf181d644b05490f3374d9fd89e190811 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 19:02:49 +0200 Subject: [PATCH 42/86] wait on hardhat node before starting worker --- package.json | 7 ++++--- yarn.lock | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 57 insertions(+), 5 deletions(-) diff --git a/package.json b/package.json index f392d2eb..3bd5748a 100644 --- a/package.json +++ b/package.json @@ -59,7 +59,8 @@ "tsconfig-paths": "^3.14.1", "typechain": "^8.1.0", "typescript": "^4.6.3", - "uniswap-v2-deploy-plugin": "^0.0.4" + "uniswap-v2-deploy-plugin": "^0.0.4", + "wait-on": "^7.2.0" }, "files": [ "contracts", @@ -84,12 +85,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", - "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"yarn worker\"", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", - "worker": "npx hardhat run scripts/worker.ts --network localhost" + "worker": "npx hardhat run scripts/worker.ts --network localhost", + "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/yarn.lock b/yarn.lock index 2d84082a..9202ef21 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1231,6 +1231,18 @@ optionalDependencies: "@trufflesuite/bigint-buffer" "1.1.9" +"@hapi/hoek@^9.0.0", "@hapi/hoek@^9.3.0": + version "9.3.0" + resolved "https://registry.yarnpkg.com/@hapi/hoek/-/hoek-9.3.0.tgz#8368869dcb735be2e7f5cb7647de78e167a251fb" + integrity sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ== + +"@hapi/topo@^5.1.0": + version "5.1.0" + resolved "https://registry.yarnpkg.com/@hapi/topo/-/topo-5.1.0.tgz#dc448e332c6c6e37a4dc02fd84ba8d44b9afb012" + integrity sha512-foQZKJig7Ob0BMAYBfcJk8d77QtOe7Wo4ox7ff1lQYoNNAb6jwcY1ncdoy2e9wQZzvNy7ODZCYJkK8kzmcAnAg== + dependencies: + "@hapi/hoek" "^9.0.0" + "@humanwhocodes/config-array@^0.11.8": version "0.11.8" resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.8.tgz" @@ -1838,6 +1850,23 @@ "@sentry/types" "5.30.0" tslib "^1.9.3" +"@sideway/address@^4.1.5": + version "4.1.5" + resolved "https://registry.yarnpkg.com/@sideway/address/-/address-4.1.5.tgz#4bc149a0076623ced99ca8208ba780d65a99b9d5" + integrity sha512-IqO/DUQHUkPeixNQ8n0JA6102hT9CmaljNTPmQ1u8MEhBo/R4Q8eKLN/vGZxuebwOroDB4cbpjheD4+/sKFK4Q== + dependencies: + "@hapi/hoek" "^9.0.0" + +"@sideway/formula@^3.0.1": + version "3.0.1" + resolved "https://registry.yarnpkg.com/@sideway/formula/-/formula-3.0.1.tgz#80fcbcbaf7ce031e0ef2dd29b1bfc7c3f583611f" + integrity sha512-/poHZJJVjx3L+zVD6g9KgHfYnb443oi7wLu/XKojDviHy6HOEOA6z1Trk5aR1dGcmPenJEgb2sK2I80LeS3MIg== + +"@sideway/pinpoint@^2.0.0": + version "2.0.0" + resolved "https://registry.yarnpkg.com/@sideway/pinpoint/-/pinpoint-2.0.0.tgz#cff8ffadc372ad29fd3f78277aeb29e632cc70df" + integrity sha512-RNiOoTPkptFtSVzQevY/yWtZwf/RxyVnPy/OcA9HBM3MlGDnBEYL5B41H0MTn0Uec8Hi+2qUtTfG2WWZBmMejQ== + "@sindresorhus/is@^5.2.0": version "5.6.0" resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-5.6.0.tgz" @@ -2781,7 +2810,7 @@ axios@^0.21.2: dependencies: follow-redirects "^1.14.0" -axios@^1.4.0: +axios@^1.4.0, axios@^1.6.1: version "1.7.2" resolved "https://registry.yarnpkg.com/axios/-/axios-1.7.2.tgz#b625db8a7051fbea61c35a3cbb3a1daa7b9c7621" integrity sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw== @@ -6433,6 +6462,17 @@ isstream@~0.1.2: resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz" integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g== +joi@^17.11.0: + version "17.13.3" + resolved "https://registry.yarnpkg.com/joi/-/joi-17.13.3.tgz#0f5cc1169c999b30d344366d384b12d92558bcec" + integrity sha512-otDA4ldcIx+ZXsKHWmp0YizCweVRZG96J10b0FevjfuncLO1oX59THoAmHkNubYJ+9gWsYsp5k8v4ib6oDv1fA== + dependencies: + "@hapi/hoek" "^9.3.0" + "@hapi/topo" "^5.1.0" + "@sideway/address" "^4.1.5" + "@sideway/formula" "^3.0.1" + "@sideway/pinpoint" "^2.0.0" + js-cookie@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/js-cookie/-/js-cookie-2.2.1.tgz#69e106dc5d5806894562902aa5baec3744e9b2b8" @@ -7189,7 +7229,7 @@ minimist-options@4.1.0, minimist-options@^4.0.2: is-plain-obj "^1.1.0" kind-of "^6.0.3" -minimist@^1.1.0, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@^1.2.7: +minimist@^1.1.0, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@^1.2.7, minimist@^1.2.8: version "1.2.8" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== @@ -9822,6 +9862,17 @@ verror@1.10.0: core-util-is "1.0.2" extsprintf "^1.2.0" +wait-on@^7.2.0: + version "7.2.0" + resolved "https://registry.yarnpkg.com/wait-on/-/wait-on-7.2.0.tgz#d76b20ed3fc1e2bebc051fae5c1ff93be7892928" + integrity sha512-wCQcHkRazgjG5XoAq9jbTMLpNIjoSlZslrJ2+N9MxDsGEv1HnFoVjOCexL0ESva7Y9cu350j+DWADdk54s4AFQ== + dependencies: + axios "^1.6.1" + joi "^17.11.0" + lodash "^4.17.21" + minimist "^1.2.8" + rxjs "^7.8.1" + wcwidth@^1.0.1: version "1.0.1" resolved "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz" From fa96e3096253186806dfba0c7d5f423cc61445bc Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 19:03:57 +0200 Subject: [PATCH 43/86] remove redundant hardhat config --- hardhat.config.ts | 5 ----- 1 file changed, 5 deletions(-) diff --git a/hardhat.config.ts b/hardhat.config.ts index d58755a4..8fdc1844 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -43,11 +43,6 @@ const config: HardhatUserConfig = { }, networks: { ...getHardhatConfigNetworks(), - localhost: { - gas: 30_000_000, - gasLimit: 30_000_000, - url: "http://localhost:8545", - }, }, solidity: { compilers: [ From b5a665ac2472ac886c50317b41a09dca9afe18ed Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 19:16:13 +0200 Subject: [PATCH 44/86] generate --- package.json | 4 ++-- scripts/worker.ts | 28 ++++++++++------------------ 2 files changed, 12 insertions(+), 20 deletions(-) diff --git a/package.json b/package.json index 3bd5748a..5e987a5f 100644 --- a/package.json +++ b/package.json @@ -85,12 +85,12 @@ "lint": "npx eslint . --ext .js,.ts", "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", "lint:sol": "solhint 'contracts/**/*.sol'", + "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"", "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", - "worker": "npx hardhat run scripts/worker.ts --network localhost", - "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"" + "worker": "npx hardhat run scripts/worker.ts --network localhost" }, "types": "./dist/lib/index.d.ts", "version": "0.0.8" diff --git a/scripts/worker.ts b/scripts/worker.ts index 78c25d17..9b9553dd 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -153,17 +153,15 @@ export const startWorker = async () => { console.log("Worker: Call event on GatewayEVM."); console.log("Worker: Calling TestZContract through GatewayZEVM..."); const zContract = args[1]; - const payload = args[2] - const executeTx = await gatewayZEVM - .connect(fungibleModuleSigner) - .execute( - [gatewayZEVM.address, fungibleModuleSigner.address, 1], - // onCrosschainCall contains zrc20 and amount which is not available in Call event - ZRC20Contract.address, - parseEther("0"), - zContract, - payload, - ); + const payload = args[2]; + const executeTx = await gatewayZEVM.connect(fungibleModuleSigner).execute( + [gatewayZEVM.address, fungibleModuleSigner.address, 1], + // onCrosschainCall contains zrc20 and amount which is not available in Call event + ZRC20Contract.address, + parseEther("0"), + zContract, + payload + ); await executeTx.wait(); }); @@ -177,13 +175,7 @@ export const startWorker = async () => { console.log("Worker: Calling TestZContract through GatewayZEVM..."); const executeTx = await gatewayZEVM .connect(fungibleModuleSigner) - .execute( - [gatewayZEVM.address, fungibleModuleSigner.address, 1], - asset, - parseEther("0"), - receiver, - payload, - ); + .execute([gatewayZEVM.address, fungibleModuleSigner.address, 1], asset, parseEther("0"), receiver, payload); await executeTx.wait(); } }); From badd4f85d27616e0969ba0d60cf962fb3e2b9dea Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 19:18:15 +0200 Subject: [PATCH 45/86] add tasks to coderabbit --- .coderabbit.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 5eb60fc3..b1b55736 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -14,6 +14,9 @@ reviews: - path: 'scripts/**' instructions: >- Review the scripts for best practices. + - path: 'tasks/**' + instructions: >- + Review the tasks for best practices. auto_review: base_branches: - main \ No newline at end of file From d158c7182c2aef6350bef4e105b361a189c3722c Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 19:55:38 +0200 Subject: [PATCH 46/86] improve instructions --- .coderabbit.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index b1b55736..03f26323 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -13,10 +13,10 @@ reviews: Review the test files for proper coverage, edge cases, and best practices. - path: 'scripts/**' instructions: >- - Review the scripts for best practices. + Review the Hardhat scripts for best practices. - path: 'tasks/**' instructions: >- - Review the tasks for best practices. + Review the Hardhat tasks for best practices. auto_review: base_branches: - main \ No newline at end of file From 49223b2dd9210f8e1df56f1b47a7948e77e0d0fa Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 20:01:51 +0200 Subject: [PATCH 47/86] exclude in coderabbit --- .coderabbit.yaml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 03f26323..3faabaaf 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -1,9 +1,9 @@ reviews: path_filters: - - "pkg/**" - - "typechain-types/**" - - "docs/**" - - "data/**" + - "!pkg/**" + - "!typechain-types/**" + - "!docs/**" + - "!data/**" path_instructions: - path: 'contracts/**' instructions: >- From 4275805b95ac425e52a48c5c574cff5032c8b6ab Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 20:17:46 +0200 Subject: [PATCH 48/86] test config changes --- .coderabbit.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 3faabaaf..04518279 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -4,6 +4,9 @@ reviews: - "!typechain-types/**" - "!docs/**" - "!data/**" + - "contracts/**" + - "scripts/**" + - "tasks/**" path_instructions: - path: 'contracts/**' instructions: >- From caae6879b585c951350646ed2bc5e47f60f3892b Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 20:37:35 +0200 Subject: [PATCH 49/86] revert --- .coderabbit.yaml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.coderabbit.yaml b/.coderabbit.yaml index 04518279..3faabaaf 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -4,9 +4,6 @@ reviews: - "!typechain-types/**" - "!docs/**" - "!data/**" - - "contracts/**" - - "scripts/**" - - "tasks/**" path_instructions: - path: 'contracts/**' instructions: >- From 0c1b3706f1d2747f1d88b68bd1064bf54d6d69d5 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 21:32:10 +0200 Subject: [PATCH 50/86] add try catch --- tasks/localnet.ts | 57 ++++++++++++++++++++++++++++++----------------- 1 file changed, 36 insertions(+), 21 deletions(-) diff --git a/tasks/localnet.ts b/tasks/localnet.ts index 1f864d10..0acc9591 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -19,10 +19,13 @@ task("zevm-call", "calls evm contract from zevm account") // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); - const callTx = await gatewayZEVM.call(receiverEVM.address, message); - await callTx.wait(); - - console.log("ReceiverEVM called from ZEVM"); + try { + const callTx = await gatewayZEVM.call(receiverEVM.address, message); + await callTx.wait(); + console.log("ReceiverEVM called from ZEVM"); + } catch (e) { + console.error("Error calling ReceiverEVM:", e); + } }); task("zevm-withdraw-and-call", "withdraws zrc20 and calls evm contract from zevm account") @@ -42,12 +45,16 @@ task("zevm-withdraw-and-call", "withdraws zrc20 and calls evm contract from zevm // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); - const callTx = await gatewayZEVM - .connect(ownerZEVM) - .withdrawAndCall(receiverEVM.address, hre.ethers.utils.parseEther(taskArgs.amount), zrc20.address, message); - await callTx.wait(); - console.log("ReceiverEVM called from ZEVM"); + try { + const callTx = await gatewayZEVM + .connect(ownerZEVM) + .withdrawAndCall(receiverEVM.address, hre.ethers.utils.parseEther(taskArgs.amount), zrc20.address, message); + await callTx.wait(); + console.log("ReceiverEVM called from ZEVM"); + } catch (e) { + console.error("Error calling ReciverEVM:", e); + } }); task("evm-call", "calls zevm zcontract from evm account") @@ -58,10 +65,14 @@ task("evm-call", "calls zevm zcontract from evm account") const zContract = await hre.ethers.getContractAt("TestZContract", taskArgs.zContract); const message = hre.ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); - const callTx = await gatewayEVM.call(zContract.address, message); - await callTx.wait(); - console.log("TestZContract called from EVM"); + try { + const callTx = await gatewayEVM.call(zContract.address, message); + await callTx.wait(); + console.log("TestZContract called from EVM"); + } catch (e) { + console.error("Error calling TestZContract:", e); + } }); task("evm-deposit-and-call", "deposits erc20 and calls zevm zcontract from evm account") @@ -77,13 +88,17 @@ task("evm-deposit-and-call", "deposits erc20 and calls zevm zcontract from evm a await erc20.approve(gatewayEVM.address, hre.ethers.utils.parseEther(taskArgs.amount)); const payload = hre.ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); - const callTx = await gatewayEVM["depositAndCall(address,uint256,address,bytes)"]( - zContract.address, - hre.ethers.utils.parseEther(taskArgs.amount), - erc20.address, - payload - ); - await callTx.wait(); - - console.log("TestZContract called from EVM"); + + try { + const callTx = await gatewayEVM["depositAndCall(address,uint256,address,bytes)"]( + zContract.address, + hre.ethers.utils.parseEther(taskArgs.amount), + erc20.address, + payload + ); + await callTx.wait(); + console.log("TestZContract called from EVM"); + } catch (e) { + console.error("Error calling TestZContract:", e); + } }); From e62b051563bca53775dd126c1be38ccd3c34afaf Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 21:45:41 +0200 Subject: [PATCH 51/86] cleanup --- scripts/readme.md | 2 +- scripts/worker.ts | 10 ++++++---- tasks/localnet.ts | 6 +++--- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/scripts/readme.md b/scripts/readme.md index 7e04e34f..ecc0a0ef 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -7,4 +7,4 @@ yarn localnet ``` This will run hardhat local node and worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. -Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. +Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. diff --git a/scripts/worker.ts b/scripts/worker.ts index 9b9553dd..7571523a 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -16,7 +16,7 @@ export const startWorker = async () => { let gatewayEVM: Contract; let token: Contract; let custody: Contract; - let ownerEVM: any, destination: any, tssAddress: any; + let ownerEVM: any, tssAddress: any; // ZEVM let senderZEVM: Contract; @@ -27,7 +27,8 @@ export const startWorker = async () => { let ownerZEVM: SignerWithAddress; let addrs: SignerWithAddress[]; - [ownerEVM, ownerZEVM, destination, tssAddress, ...addrs] = await ethers.getSigners(); + [ownerEVM, ownerZEVM, tssAddress, ...addrs] = await ethers.getSigners(); + // Prepare EVM const TestERC20 = await ethers.getContractFactory("TestERC20"); const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); @@ -60,6 +61,7 @@ export const startWorker = async () => { console.log("EVM: 500TTK transfered to custody from:", ownerEVM.address); // Prepare ZEVM + // Impersonate the fungible module account await hre.network.provider.request({ method: "hardhat_impersonateAccount", @@ -137,7 +139,7 @@ export const startWorker = async () => { console.log("Worker: Withdrawal event on GatewayZEVM."); const receiver = args[1]; const message = args[5]; - if (args[5] != "0x") { + if (message != "0x") { console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); const executeTx = await gatewayEVM.execute(receiver, message, { value: 0 }); await executeTx.wait(); @@ -171,7 +173,7 @@ export const startWorker = async () => { const receiver = args[1]; const asset = args[3]; const payload = args[4]; - if (args[4] != "0x") { + if (payload != "0x") { console.log("Worker: Calling TestZContract through GatewayZEVM..."); const executeTx = await gatewayZEVM .connect(fungibleModuleSigner) diff --git a/tasks/localnet.ts b/tasks/localnet.ts index 0acc9591..2c24783b 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -2,9 +2,9 @@ import { task } from "hardhat/config"; declare const hre: any; -// Contains tasks to make it easier to interact with prototype contracts localnet -// To make use of default contract addresses on localnet, start localnode and localnet from scratch, so contracts are deployed on same addresses -// Otherwise, provide custom addresses as parameters +// Contains tasks to make it easier to interact with prototype contracts localnet. +// To make use of default contract addresses on localnet, start localnet from scratch, so contracts are deployed on same addresses. +// Otherwise, provide custom addresses as parameters. task("zevm-call", "calls evm contract from zevm account") .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") From b69926f6400a1e311dddab04bf510bdbfcd83555 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 3 Jul 2024 22:16:08 +0200 Subject: [PATCH 52/86] add basic property based invariants for gateway evm --- .gitignore | 4 +- .../prototypes/evm/GatewayEVMEchidnaTest.sol | 56 +++++++++++++++++++ echidna.yaml | 2 + 3 files changed, 61 insertions(+), 1 deletion(-) create mode 100644 contracts/prototypes/evm/GatewayEVMEchidnaTest.sol create mode 100644 echidna.yaml diff --git a/.gitignore b/.gitignore index a299b173..39218d50 100644 --- a/.gitignore +++ b/.gitignore @@ -30,4 +30,6 @@ coverage.json scripts/slither-results/* !scripts/slither-results/.gitkeep -abi \ No newline at end of file +abi + +crytic-export \ No newline at end of file diff --git a/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol b/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol new file mode 100644 index 00000000..c0e04b4b --- /dev/null +++ b/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol @@ -0,0 +1,56 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "./GatewayEVM.sol"; +import "./TestERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +contract GatewayEVMEchidnaTest is GatewayEVM { + using SafeERC20 for IERC20; + address e = msg.sender; + bool initialized = false; + + TestERC20 testERC20; + + // Add a constructor to bypass the initializer + constructor() { + // Do nothing here to avoid calling initialize during deployment + } + + // Function to initialize the contract for testing + function initializeTest() public { + __Ownable_init(); + __UUPSUpgradeable_init(); + + if (e == address(0)) { + revert ZeroAddress(); + } + tssAddress = e; + initialized = true; + + testERC20 = new TestERC20("test", "TEST"); + testERC20.mint(e, 100000000000); + } + + // Invariant to check that the contract balance is always zero + function echidna_balance_is_zero() public view returns (bool) { + return address(this).balance == 0; + } + + // Invariant to check that the contract doesn't hold any ERC20 tokens + function echidna_no_erc20_balance() public view returns (bool) { + if (initialized == false) { + return true; + } + return testERC20.balanceOf(address(this)) == 0; + } + + // Invariant to check that the TSS address is never zero after initialization + function echidna_tss_address_not_zero() public view returns (bool) { + if (initialized == false) { + return true; + } + return tssAddress != address(0); + } +} \ No newline at end of file diff --git a/echidna.yaml b/echidna.yaml new file mode 100644 index 00000000..9259a5d1 --- /dev/null +++ b/echidna.yaml @@ -0,0 +1,2 @@ +# provide solc remappings to crytic-compile +cryticArgs: ['--solc-remaps', '@=node_modules/@'] \ No newline at end of file From bb27a54b932a3ed5513fda5fe7cac8b2b0cc1de8 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 4 Jul 2024 14:43:30 +0200 Subject: [PATCH 53/86] PR comments --- scripts/worker.ts | 170 ++++++++++++++++++++++------------------------ tasks/localnet.ts | 14 ++-- 2 files changed, 88 insertions(+), 96 deletions(-) diff --git a/scripts/worker.ts b/scripts/worker.ts index 7571523a..c979dd45 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -1,7 +1,6 @@ import { AddressZero } from "@ethersproject/constants"; import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; import { SystemContract, ZRC20 } from "@typechain-types"; -import { Contract } from "ethers"; import { parseEther } from "ethers/lib/utils"; import { ethers, upgrades } from "hardhat"; @@ -9,107 +8,77 @@ const hre = require("hardhat"); export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; -export const startWorker = async () => { - console.log("worker starting"); - // EVM - let receiverEVM: Contract; - let gatewayEVM: Contract; - let token: Contract; - let custody: Contract; - let ownerEVM: any, tssAddress: any; - - // ZEVM - let senderZEVM: Contract; - let ZRC20Contract: ZRC20; - let systemContract: SystemContract; - let gatewayZEVM: Contract; - let testZContract: Contract; - let ownerZEVM: SignerWithAddress; - let addrs: SignerWithAddress[]; - - [ownerEVM, ownerZEVM, tssAddress, ...addrs] = await ethers.getSigners(); - +const deploySystemContracts = async(tss: SignerWithAddress) => { // Prepare EVM - const TestERC20 = await ethers.getContractFactory("TestERC20"); - const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); + // Deploy system contracts (gateway and custody) const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); - // Deploy the contracts - token = await TestERC20.deploy("Test Token", "TTK"); - console.log("EVM: ERC20(TTK) token deployed to:", token.address); - - receiverEVM = await ReceiverEVM.deploy(); - console.log("EVM: Receiver deployed to:", receiverEVM.address); - - gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tssAddress.address], { + const gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tss.address], { initializer: "initialize", kind: "uups", }); - console.log("EVM: GatewayEVM deployed to:", gatewayEVM.address); + console.log("GatewayEVM:", gatewayEVM.address); - custody = await Custody.deploy(gatewayEVM.address); - gatewayEVM.setCustody(custody.address); - console.log("EVM: ERC20Custody deployed to:", custody.address); - - // Mint initial supply to the owner - await token.mint(ownerEVM.address, ethers.utils.parseEther("1000")); - console.log("EVM: 1000TTK minted to:", ownerEVM.address); - - // Transfer some tokens to the custody contract - await token.transfer(custody.address, ethers.utils.parseEther("500")); - console.log("EVM: 500TTK transfered to custody from:", ownerEVM.address); + const custody = await Custody.deploy(gatewayEVM.address); + await gatewayEVM.setCustody(custody.address); // Prepare ZEVM - - // Impersonate the fungible module account - await hre.network.provider.request({ - method: "hardhat_impersonateAccount", - params: [FUNGIBLE_MODULE_ADDRESS], - }); - - // Get a signer for the fungible module account - const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); - hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); - + // Deploy system contracts (gateway and system) const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); - systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; - console.log("ZEVM: SystemContract deployed to:", systemContract.address); + const systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; const GatewayZEVM = await ethers.getContractFactory("GatewayZEVM"); - gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [], { + const gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [], { initializer: "initialize", kind: "uups", }); - console.log("ZEVM: GatewayZEVM deployed to:", gatewayZEVM.address); + console.log("GatewayZEVM:", gatewayZEVM.address); + + return { + gatewayEVM, + custody, + gatewayZEVM, + systemContract, + }; +} +const deployTestContracts = async (systemContracts, ownerEVM: SignerWithAddress, ownerZEVM: SignerWithAddress, fungibleModuleSigner: SignerWithAddress) => { + // Prepare EVM + // Deploy test contracts (erc20, receiver) and mint funds to test accounts + const TestERC20 = await ethers.getContractFactory("TestERC20"); + const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); + + const token = await TestERC20.deploy("Test Token", "TTK"); + const receiverEVM = await ReceiverEVM.deploy(); + await token.mint(ownerEVM.address, ethers.utils.parseEther("1000")); + + // Transfer some tokens to the custody contract + await token.transfer(systemContracts.custody.address, ethers.utils.parseEther("500")); + + // Prepare ZEVM + // Deploy test contracts (test zContract, zrc20, sender) and mint funds to test accounts const TestZContract = await ethers.getContractFactory("TestZContract"); - testZContract = await TestZContract.deploy(); - console.log("ZEVM: TestZContract deployed to:", testZContract.address); + const testZContract = await TestZContract.deploy(); const ZRC20Factory = await ethers.getContractFactory("ZRC20New"); - ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( + const ZRC20Contract = (await ZRC20Factory.connect(fungibleModuleSigner).deploy( "TOKEN", "TKN", 18, 1, 1, 0, - systemContract.address, - gatewayZEVM.address + systemContracts.systemContract.address, + systemContracts.gatewayZEVM.address )) as ZRC20; - console.log("ZEVM: ZRC20(TKN) contract deployed to:", ZRC20Contract.address); - - await systemContract.setGasCoinZRC20(1, ZRC20Contract.address); - await systemContract.setGasPrice(1, ZRC20Contract.address); + await systemContracts.systemContract.setGasCoinZRC20(1, ZRC20Contract.address); + await systemContracts.systemContract.setGasPrice(1, ZRC20Contract.address); await ZRC20Contract.connect(fungibleModuleSigner).deposit(ownerZEVM.address, parseEther("100")); - console.log("ZEVM: Fungible module deposited 100TKN to:", ownerZEVM.address); - - await ZRC20Contract.connect(ownerZEVM).approve(gatewayZEVM.address, parseEther("100")); - console.log(`ZEVM: ${ownerZEVM.address} approved GatewayZEVM ${gatewayZEVM.address} 100TKN`); + await ZRC20Contract.connect(ownerZEVM).approve(systemContracts.gatewayZEVM.address, parseEther("100")); - // including abi of gatewayZEVM events, so hardhat can decode them automatically + // Include abi of gatewayZEVM events, so hardhat can decode them automatically const senderArtifact = await hre.artifacts.readArtifact("SenderZEVM"); const gatewayZEVMArtifact = await hre.artifacts.readArtifact("GatewayZEVM"); const senderABI = [ @@ -118,48 +87,71 @@ export const startWorker = async () => { ]; const SenderZEVM = new ethers.ContractFactory(senderABI, senderArtifact.bytecode, ownerZEVM); - senderZEVM = await SenderZEVM.deploy(gatewayZEVM.address); - console.log("ZEVM: Sender contract deployed to:", senderZEVM.address); - + const senderZEVM = await SenderZEVM.deploy(systemContracts.gatewayZEVM.address); await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); - console.log("ZEVM: Fungible module deposited 100TKN to sender:", senderZEVM.address); + return { + receiverEVM, + senderZEVM, + ZRC20Contract, + testZContract, + }; +}; + +export const startWorker = async () => { + const [ownerEVM, ownerZEVM, tss] = await ethers.getSigners(); + + // Impersonate the fungible module account + await hre.network.provider.request({ + method: "hardhat_impersonateAccount", + params: [FUNGIBLE_MODULE_ADDRESS], + }); + + // Get a signer for the fungible module account + const fungibleModuleSigner = await ethers.getSigner(FUNGIBLE_MODULE_ADDRESS); + hre.network.provider.send("hardhat_setBalance", [FUNGIBLE_MODULE_ADDRESS, parseEther("1000000").toHexString()]); + + // Deploy system and test contracts + const systemContracts = await deploySystemContracts(tss); + const testContracts = await deployTestContracts(systemContracts, ownerEVM, ownerZEVM, fungibleModuleSigner); + + // Listen to contracts events // event Call(address indexed sender, bytes receiver, bytes message); - gatewayZEVM.on("Call", async (...args: Array) => { + systemContracts.gatewayZEVM.on("Call", async (...args: Array) => { console.log("Worker: Call event on GatewayZEVM."); console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); const receiver = args[1]; const message = args[2]; - const executeTx = await gatewayEVM.execute(receiver, message, { value: 0 }); + const executeTx = await systemContracts.gatewayEVM.execute(receiver, message, { value: 0 }); await executeTx.wait(); }); // event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); - gatewayZEVM.on("Withdrawal", async (...args: Array) => { + systemContracts.gatewayZEVM.on("Withdrawal", async (...args: Array) => { console.log("Worker: Withdrawal event on GatewayZEVM."); const receiver = args[1]; const message = args[5]; if (message != "0x") { console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); - const executeTx = await gatewayEVM.execute(receiver, message, { value: 0 }); + const executeTx = await systemContracts.gatewayEVM.execute(receiver, message, { value: 0 }); await executeTx.wait(); } }); - receiverEVM.on("ReceivedPayable", () => { + testContracts.receiverEVM.on("ReceivedPayable", () => { console.log("ReceiverEVM: receivePayable called!"); }); // event Call(address indexed sender, address indexed receiver, bytes payload); - gatewayEVM.on("Call", async (...args: Array) => { + systemContracts.gatewayEVM.on("Call", async (...args: Array) => { console.log("Worker: Call event on GatewayEVM."); console.log("Worker: Calling TestZContract through GatewayZEVM..."); const zContract = args[1]; const payload = args[2]; - const executeTx = await gatewayZEVM.connect(fungibleModuleSigner).execute( - [gatewayZEVM.address, fungibleModuleSigner.address, 1], + const executeTx = await systemContracts.gatewayZEVM.connect(fungibleModuleSigner).execute( + [systemContracts.gatewayZEVM.address, fungibleModuleSigner.address, 1], // onCrosschainCall contains zrc20 and amount which is not available in Call event - ZRC20Contract.address, + testContracts.ZRC20Contract.address, parseEther("0"), zContract, payload @@ -168,21 +160,21 @@ export const startWorker = async () => { }); // event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); - gatewayEVM.on("Deposit", async (...args: Array) => { + systemContracts.gatewayEVM.on("Deposit", async (...args: Array) => { console.log("Worker: Deposit event on GatewayEVM."); const receiver = args[1]; const asset = args[3]; const payload = args[4]; if (payload != "0x") { console.log("Worker: Calling TestZContract through GatewayZEVM..."); - const executeTx = await gatewayZEVM + const executeTx = await systemContracts.gatewayZEVM .connect(fungibleModuleSigner) - .execute([gatewayZEVM.address, fungibleModuleSigner.address, 1], asset, parseEther("0"), receiver, payload); + .execute([systemContracts.gatewayZEVM.address, fungibleModuleSigner.address, 1], asset, parseEther("0"), receiver, payload); await executeTx.wait(); } }); - testZContract.on("ContextData", async () => { + testContracts.testZContract.on("ContextData", async () => { console.log("TestZContract: onCrosschainCall called!"); }); diff --git a/tasks/localnet.ts b/tasks/localnet.ts index 2c24783b..b57f21a9 100644 --- a/tasks/localnet.ts +++ b/tasks/localnet.ts @@ -7,8 +7,8 @@ declare const hre: any; // Otherwise, provide custom addresses as parameters. task("zevm-call", "calls evm contract from zevm account") - .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") - .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") + .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x413b1AfCa96a3df5A686d8BFBF93d30688a7f7D9") + .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0x821f3361D454cc98b7555221A06Be563a7E2E0A6") .setAction(async (taskArgs) => { const gatewayZEVM = await hre.ethers.getContractAt("GatewayZEVM", taskArgs.gatewayZEVM); const receiverEVM = await hre.ethers.getContractAt("ReceiverEVM", taskArgs.receiverEVM); @@ -29,8 +29,8 @@ task("zevm-call", "calls evm contract from zevm account") }); task("zevm-withdraw-and-call", "withdraws zrc20 and calls evm contract from zevm account") - .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x5133BBdfCCa3Eb4F739D599ee4eC45cBCD0E16c5") - .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") + .addOptionalParam("gatewayZEVM", "contract address of gateway on ZEVM", "0x413b1AfCa96a3df5A686d8BFBF93d30688a7f7D9") + .addOptionalParam("receiverEVM", "contract address of receiver on EVM", "0x821f3361D454cc98b7555221A06Be563a7E2E0A6") .addOptionalParam("zrc20", "contract address of zrc20", "0x9fd96203f7b22bCF72d9DCb40ff98302376cE09c") .addOptionalParam("amount", "amount to withdraw", "1") .setAction(async (taskArgs) => { @@ -58,7 +58,7 @@ task("zevm-withdraw-and-call", "withdraws zrc20 and calls evm contract from zevm }); task("evm-call", "calls zevm zcontract from evm account") - .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") + .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") .setAction(async (taskArgs) => { const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", taskArgs.gatewayEVM); @@ -76,9 +76,9 @@ task("evm-call", "calls zevm zcontract from evm account") }); task("evm-deposit-and-call", "deposits erc20 and calls zevm zcontract from evm account") - .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xAD523115cd35a8d4E60B3C0953E0E0ac10418309") + .addOptionalParam("gatewayEVM", "contract address of gateway on EVM", "0xB06c856C8eaBd1d8321b687E188204C1018BC4E5") .addOptionalParam("zContract", "contract address of zContract on ZEVM", "0x71089Ba41e478702e1904692385Be3972B2cBf9e") - .addOptionalParam("erc20", "contract address of erc20", "0xddE78e6202518FF4936b5302cC2891ec180E8bFf") + .addOptionalParam("erc20", "contract address of erc20", "0x02df3a3F960393F5B349E40A599FEda91a7cc1A7") .addOptionalParam("amount", "amount to deposit", "1") .setAction(async (taskArgs) => { const gatewayEVM = await hre.ethers.getContractAt("GatewayEVM", taskArgs.gatewayEVM); From d80596ee260412278580da42d2ab9be07bad7014 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 4 Jul 2024 14:46:30 +0200 Subject: [PATCH 54/86] yarn generate --- scripts/worker.ts | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-) diff --git a/scripts/worker.ts b/scripts/worker.ts index c979dd45..aaf749a9 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -8,7 +8,7 @@ const hre = require("hardhat"); export const FUNGIBLE_MODULE_ADDRESS = "0x735b14BB79463307AAcBED86DAf3322B1e6226aB"; -const deploySystemContracts = async(tss: SignerWithAddress) => { +const deploySystemContracts = async (tss: SignerWithAddress) => { // Prepare EVM // Deploy system contracts (gateway and custody) const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); @@ -36,14 +36,19 @@ const deploySystemContracts = async(tss: SignerWithAddress) => { console.log("GatewayZEVM:", gatewayZEVM.address); return { - gatewayEVM, custody, + gatewayEVM, gatewayZEVM, systemContract, }; -} +}; -const deployTestContracts = async (systemContracts, ownerEVM: SignerWithAddress, ownerZEVM: SignerWithAddress, fungibleModuleSigner: SignerWithAddress) => { +const deployTestContracts = async ( + systemContracts, + ownerEVM: SignerWithAddress, + ownerZEVM: SignerWithAddress, + fungibleModuleSigner: SignerWithAddress +) => { // Prepare EVM // Deploy test contracts (erc20, receiver) and mint funds to test accounts const TestERC20 = await ethers.getContractFactory("TestERC20"); @@ -91,9 +96,9 @@ const deployTestContracts = async (systemContracts, ownerEVM: SignerWithAddress, await ZRC20Contract.connect(fungibleModuleSigner).deposit(senderZEVM.address, parseEther("100")); return { + ZRC20Contract, receiverEVM, senderZEVM, - ZRC20Contract, testZContract, }; }; @@ -169,7 +174,13 @@ export const startWorker = async () => { console.log("Worker: Calling TestZContract through GatewayZEVM..."); const executeTx = await systemContracts.gatewayZEVM .connect(fungibleModuleSigner) - .execute([systemContracts.gatewayZEVM.address, fungibleModuleSigner.address, 1], asset, parseEther("0"), receiver, payload); + .execute( + [systemContracts.gatewayZEVM.address, fungibleModuleSigner.address, 1], + asset, + parseEther("0"), + receiver, + payload + ); await executeTx.wait(); } }); From d0ad2f5af76b4dde4195b03b712a4ef2928ce78b Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 4 Jul 2024 19:53:18 +0200 Subject: [PATCH 55/86] add simple assertion tests --- .eslintignore | 3 +- contracts/prototypes/evm/ERC20CustodyNew.sol | 2 +- .../evm/ERC20CustodyNewEchidnaTest.sol | 33 + contracts/prototypes/evm/GatewayEVM.sol | 6 +- .../prototypes/evm/GatewayEVMEchidnaTest.sol | 50 +- echidna.yaml | 8 +- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../erc20custodynewechidnatest.go | 668 ++++++ .../evm/gatewayevm.sol/gatewayevm.go | 4 +- .../gatewayevmechidnatest.go | 2004 +++++++++++++++++ scripts/readme.md | 5 + .../evm/ERC20CustodyNewEchidnaTest.ts | 331 +++ .../prototypes/evm/GatewayEVMEchidnaTest.ts | 935 ++++++++ .../contracts/prototypes/evm/index.ts | 2 + .../ERC20CustodyNewEchidnaTest__factory.ts | 246 ++ .../evm/ERC20CustodyNew__factory.ts | 2 +- .../evm/GatewayEVMEchidnaTest__factory.ts | 638 ++++++ .../prototypes/evm/GatewayEVM__factory.ts | 7 +- .../contracts/prototypes/evm/index.ts | 2 + typechain-types/hardhat.d.ts | 18 + typechain-types/index.ts | 4 + 21 files changed, 4920 insertions(+), 50 deletions(-) create mode 100644 contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol create mode 100644 pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go create mode 100644 pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go create mode 100644 typechain-types/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.ts create mode 100644 typechain-types/contracts/prototypes/evm/GatewayEVMEchidnaTest.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory.ts diff --git a/.eslintignore b/.eslintignore index 8e5d8408..7b3ae51a 100644 --- a/.eslintignore +++ b/.eslintignore @@ -4,4 +4,5 @@ cache dist node_modules typechain-types -docs \ No newline at end of file +docs +crytic-export \ No newline at end of file diff --git a/contracts/prototypes/evm/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol index dc4dc11c..89a1c597 100644 --- a/contracts/prototypes/evm/ERC20CustodyNew.sol +++ b/contracts/prototypes/evm/ERC20CustodyNew.sol @@ -38,7 +38,7 @@ contract ERC20CustodyNew is ReentrancyGuard{ // For this, it passes through the Gateway contract, it transfers the tokens to the Gateway contract and then calls the contract // TODO: Finalize access control // https://github.com/zeta-chain/protocol-contracts/issues/204 - function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) external nonReentrant { + function withdrawAndCall(address token, address to, uint256 amount, bytes calldata data) public nonReentrant { // Transfer the tokens to the Gateway contract IERC20(token).safeTransfer(address(gateway), amount); diff --git a/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol b/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol new file mode 100644 index 00000000..00e7ff9b --- /dev/null +++ b/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol @@ -0,0 +1,33 @@ +import "./GatewayEVM.sol"; +import "./TestERC20.sol"; +import "./ERC20CustodyNew.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +contract ERC20CustodyNewEchidnaTest is ERC20CustodyNew { + using SafeERC20 for IERC20; + + TestERC20 public testERC20; + address public echidnaCaller = msg.sender; + + GatewayEVM testGateway = new GatewayEVM(); + + constructor() ERC20CustodyNew(address(testGateway)) { + testGateway.initialize(echidnaCaller); + testERC20 = new TestERC20("test", "TEST"); + testGateway.setCustody(address(this)); + } + + // Test withdrawAndCall with assertions + function testWithdrawAndCall(address to, uint256 amount, bytes calldata data) public { + // mint more than amount + testERC20.mint(address(this), amount + 5); + // transfer overhead to gateway + testERC20.transfer(address(testGateway), 5); + + withdrawAndCall(address(testERC20), to, amount, data); + + // Assertion to ensure no ERC20 tokens are left in the gateway contract after execution + assert(testERC20.balanceOf(address(gateway)) == 0); + } +} \ No newline at end of file diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index cd86d11b..204784e7 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -18,6 +18,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error InsufficientERC20Amount(); error ZeroAddress(); error ApprovalFailed(); + error CustodyInitialized(); address public custody; address public tssAddress; @@ -27,9 +28,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); event Call(address indexed sender, address indexed receiver, bytes payload); - /// @custom:oz-upgrades-unsafe-allow constructor constructor() { - _disableInitializers(); } function initialize(address _tssAddress) public initializer { @@ -71,7 +70,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { address to, uint256 amount, bytes calldata data - ) external returns (bytes memory) { + ) public returns (bytes memory) { if (amount == 0) revert InsufficientETHAmount(); // Approve the target contract to spend the tokens if(!resetApproval(token, to)) revert ApprovalFailed(); @@ -136,6 +135,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { } function setCustody(address _custody) external { + if (custody != address(0)) revert CustodyInitialized(); custody = _custody; } diff --git a/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol b/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol index c0e04b4b..79f9f800 100644 --- a/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol +++ b/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol @@ -1,56 +1,28 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.7; - import "./GatewayEVM.sol"; import "./TestERC20.sol"; +import "./ERC20CustodyNew.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; contract GatewayEVMEchidnaTest is GatewayEVM { using SafeERC20 for IERC20; - address e = msg.sender; - bool initialized = false; - TestERC20 testERC20; + TestERC20 public testERC20; + address public echidnaCaller = msg.sender; - // Add a constructor to bypass the initializer constructor() { - // Do nothing here to avoid calling initialize during deployment - } - - // Function to initialize the contract for testing - function initializeTest() public { - __Ownable_init(); - __UUPSUpgradeable_init(); - - if (e == address(0)) { - revert ZeroAddress(); - } - tssAddress = e; - initialized = true; - + initialize(echidnaCaller); testERC20 = new TestERC20("test", "TEST"); - testERC20.mint(e, 100000000000); + custody = address(new ERC20CustodyNew(address(this))); } - // Invariant to check that the contract balance is always zero - function echidna_balance_is_zero() public view returns (bool) { - return address(this).balance == 0; - } + // Test executeWithERC20 with assertions + function testExecuteWithERC20(address to, uint256 amount, bytes calldata data) public { + testERC20.mint(address(this), amount); - // Invariant to check that the contract doesn't hold any ERC20 tokens - function echidna_no_erc20_balance() public view returns (bool) { - if (initialized == false) { - return true; - } - return testERC20.balanceOf(address(this)) == 0; - } + executeWithERC20(address(testERC20), to, amount, data); - // Invariant to check that the TSS address is never zero after initialization - function echidna_tss_address_not_zero() public view returns (bool) { - if (initialized == false) { - return true; - } - return tssAddress != address(0); + // Assertion to ensure no ERC20 tokens are left in the contract after execution + assert(testERC20.balanceOf(address(this)) == 0); } } \ No newline at end of file diff --git a/echidna.yaml b/echidna.yaml index 9259a5d1..6f1c0d64 100644 --- a/echidna.yaml +++ b/echidna.yaml @@ -1,2 +1,8 @@ # provide solc remappings to crytic-compile -cryticArgs: ['--solc-remaps', '@=node_modules/@'] \ No newline at end of file +cryticArgs: ['--solc-remaps', '@=node_modules/@'] +testMode: "assertion" +coverage: true +testLimit: 100000 +seqLen: 10000 +allContracts: false +codeSize: 0x12000 \ No newline at end of file diff --git a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index aace2068..18cbbbc4 100644 --- a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go b/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go new file mode 100644 index 00000000..df810b7f --- /dev/null +++ b/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go @@ -0,0 +1,668 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package erc20custodynewechidnatest + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ERC20CustodyNewEchidnaTestMetaData contains all meta data concerning the ERC20CustodyNewEchidnaTest contract. +var ERC20CustodyNewEchidnaTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"echidnaCaller\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testERC20\",\"outputs\":[{\"internalType\":\"contractTestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"testWithdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// ERC20CustodyNewEchidnaTestABI is the input ABI used to generate the binding from. +// Deprecated: Use ERC20CustodyNewEchidnaTestMetaData.ABI instead. +var ERC20CustodyNewEchidnaTestABI = ERC20CustodyNewEchidnaTestMetaData.ABI + +// ERC20CustodyNewEchidnaTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ERC20CustodyNewEchidnaTestMetaData.Bin instead. +var ERC20CustodyNewEchidnaTestBin = ERC20CustodyNewEchidnaTestMetaData.Bin + +// DeployERC20CustodyNewEchidnaTest deploys a new Ethereum contract, binding an instance of ERC20CustodyNewEchidnaTest to it. +func DeployERC20CustodyNewEchidnaTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20CustodyNewEchidnaTest, error) { + parsed, err := ERC20CustodyNewEchidnaTestMetaData.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(ERC20CustodyNewEchidnaTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ERC20CustodyNewEchidnaTest{ERC20CustodyNewEchidnaTestCaller: ERC20CustodyNewEchidnaTestCaller{contract: contract}, ERC20CustodyNewEchidnaTestTransactor: ERC20CustodyNewEchidnaTestTransactor{contract: contract}, ERC20CustodyNewEchidnaTestFilterer: ERC20CustodyNewEchidnaTestFilterer{contract: contract}}, nil +} + +// ERC20CustodyNewEchidnaTest is an auto generated Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTest struct { + ERC20CustodyNewEchidnaTestCaller // Read-only binding to the contract + ERC20CustodyNewEchidnaTestTransactor // Write-only binding to the contract + ERC20CustodyNewEchidnaTestFilterer // Log filterer for contract events +} + +// ERC20CustodyNewEchidnaTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewEchidnaTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewEchidnaTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ERC20CustodyNewEchidnaTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20CustodyNewEchidnaTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ERC20CustodyNewEchidnaTestSession struct { + Contract *ERC20CustodyNewEchidnaTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20CustodyNewEchidnaTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ERC20CustodyNewEchidnaTestCallerSession struct { + Contract *ERC20CustodyNewEchidnaTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ERC20CustodyNewEchidnaTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ERC20CustodyNewEchidnaTestTransactorSession struct { + Contract *ERC20CustodyNewEchidnaTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20CustodyNewEchidnaTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTestRaw struct { + Contract *ERC20CustodyNewEchidnaTest // Generic contract binding to access the raw methods on +} + +// ERC20CustodyNewEchidnaTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTestCallerRaw struct { + Contract *ERC20CustodyNewEchidnaTestCaller // Generic read-only contract binding to access the raw methods on +} + +// ERC20CustodyNewEchidnaTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ERC20CustodyNewEchidnaTestTransactorRaw struct { + Contract *ERC20CustodyNewEchidnaTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewERC20CustodyNewEchidnaTest creates a new instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. +func NewERC20CustodyNewEchidnaTest(address common.Address, backend bind.ContractBackend) (*ERC20CustodyNewEchidnaTest, error) { + contract, err := bindERC20CustodyNewEchidnaTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTest{ERC20CustodyNewEchidnaTestCaller: ERC20CustodyNewEchidnaTestCaller{contract: contract}, ERC20CustodyNewEchidnaTestTransactor: ERC20CustodyNewEchidnaTestTransactor{contract: contract}, ERC20CustodyNewEchidnaTestFilterer: ERC20CustodyNewEchidnaTestFilterer{contract: contract}}, nil +} + +// NewERC20CustodyNewEchidnaTestCaller creates a new read-only instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. +func NewERC20CustodyNewEchidnaTestCaller(address common.Address, caller bind.ContractCaller) (*ERC20CustodyNewEchidnaTestCaller, error) { + contract, err := bindERC20CustodyNewEchidnaTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTestCaller{contract: contract}, nil +} + +// NewERC20CustodyNewEchidnaTestTransactor creates a new write-only instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. +func NewERC20CustodyNewEchidnaTestTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20CustodyNewEchidnaTestTransactor, error) { + contract, err := bindERC20CustodyNewEchidnaTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTestTransactor{contract: contract}, nil +} + +// NewERC20CustodyNewEchidnaTestFilterer creates a new log filterer instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. +func NewERC20CustodyNewEchidnaTestFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20CustodyNewEchidnaTestFilterer, error) { + contract, err := bindERC20CustodyNewEchidnaTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTestFilterer{contract: contract}, nil +} + +// bindERC20CustodyNewEchidnaTest binds a generic wrapper to an already deployed contract. +func bindERC20CustodyNewEchidnaTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ERC20CustodyNewEchidnaTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ERC20CustodyNewEchidnaTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.contract.Transact(opts, method, params...) +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) EchidnaCaller(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "echidnaCaller") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) EchidnaCaller() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.EchidnaCaller(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) EchidnaCaller() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.EchidnaCaller(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) Gateway() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.Gateway(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) Gateway() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.Gateway(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) TestERC20(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "testERC20") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) TestERC20() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.TestERC20(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) TestERC20() (common.Address, error) { + return _ERC20CustodyNewEchidnaTest.Contract.TestERC20(&_ERC20CustodyNewEchidnaTest.CallOpts) +} + +// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. +// +// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) TestWithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "testWithdrawAndCall", to, amount, data) +} + +// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. +// +// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) TestWithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.TestWithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, to, amount, data) +} + +// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. +// +// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) TestWithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.TestWithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, to, amount, data) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) Withdraw(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "withdraw", token, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.Withdraw(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. +// +// Solidity: function withdraw(address token, address to, uint256 amount) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.Withdraw(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) WithdrawAndCall(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "withdrawAndCall", token, to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.WithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. +// +// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ERC20CustodyNewEchidnaTest.Contract.WithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount, data) +} + +// ERC20CustodyNewEchidnaTestWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ERC20CustodyNewEchidnaTest contract. +type ERC20CustodyNewEchidnaTestWithdrawIterator struct { + Event *ERC20CustodyNewEchidnaTestWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewEchidnaTestWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewEchidnaTestWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20CustodyNewEchidnaTestWithdraw represents a Withdraw event raised by the ERC20CustodyNewEchidnaTest contract. +type ERC20CustodyNewEchidnaTestWithdraw struct { + Token common.Address + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) FilterWithdraw(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewEchidnaTestWithdrawIterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.FilterLogs(opts, "Withdraw", tokenRule, toRule) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTestWithdrawIterator{contract: _ERC20CustodyNewEchidnaTest.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewEchidnaTestWithdraw, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.WatchLogs(opts, "Withdraw", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20CustodyNewEchidnaTestWithdraw) + if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. +// +// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) ParseWithdraw(log types.Log) (*ERC20CustodyNewEchidnaTestWithdraw, error) { + event := new(ERC20CustodyNewEchidnaTestWithdraw) + if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ERC20CustodyNewEchidnaTestWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ERC20CustodyNewEchidnaTest contract. +type ERC20CustodyNewEchidnaTestWithdrawAndCallIterator struct { + Event *ERC20CustodyNewEchidnaTestWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewEchidnaTestWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20CustodyNewEchidnaTestWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20CustodyNewEchidnaTestWithdrawAndCall represents a WithdrawAndCall event raised by the ERC20CustodyNewEchidnaTest contract. +type ERC20CustodyNewEchidnaTestWithdrawAndCall struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewEchidnaTestWithdrawAndCallIterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.FilterLogs(opts, "WithdrawAndCall", tokenRule, toRule) + if err != nil { + return nil, err + } + return &ERC20CustodyNewEchidnaTestWithdrawAndCallIterator{contract: _ERC20CustodyNewEchidnaTest.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewEchidnaTestWithdrawAndCall, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.WatchLogs(opts, "WithdrawAndCall", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20CustodyNewEchidnaTestWithdrawAndCall) + if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. +// +// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) +func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) ParseWithdrawAndCall(log types.Log) (*ERC20CustodyNewEchidnaTestWithdrawAndCall, error) { + event := new(ERC20CustodyNewEchidnaTestWithdrawAndCall) + if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index e3f1ec4e..374ca35b 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -31,8 +31,8 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go b/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go new file mode 100644 index 00000000..065da1ef --- /dev/null +++ b/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go @@ -0,0 +1,2004 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayevmechidnatest + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// GatewayEVMEchidnaTestMetaData contains all meta data concerning the GatewayEVMEchidnaTest contract. +var GatewayEVMEchidnaTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"echidnaCaller\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testERC20\",\"outputs\":[{\"internalType\":\"contractTestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"testExecuteWithERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayEVMEchidnaTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMEchidnaTestMetaData.ABI instead. +var GatewayEVMEchidnaTestABI = GatewayEVMEchidnaTestMetaData.ABI + +// GatewayEVMEchidnaTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMEchidnaTestMetaData.Bin instead. +var GatewayEVMEchidnaTestBin = GatewayEVMEchidnaTestMetaData.Bin + +// DeployGatewayEVMEchidnaTest deploys a new Ethereum contract, binding an instance of GatewayEVMEchidnaTest to it. +func DeployGatewayEVMEchidnaTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVMEchidnaTest, error) { + parsed, err := GatewayEVMEchidnaTestMetaData.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(GatewayEVMEchidnaTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayEVMEchidnaTest{GatewayEVMEchidnaTestCaller: GatewayEVMEchidnaTestCaller{contract: contract}, GatewayEVMEchidnaTestTransactor: GatewayEVMEchidnaTestTransactor{contract: contract}, GatewayEVMEchidnaTestFilterer: GatewayEVMEchidnaTestFilterer{contract: contract}}, nil +} + +// GatewayEVMEchidnaTest is an auto generated Go binding around an Ethereum contract. +type GatewayEVMEchidnaTest struct { + GatewayEVMEchidnaTestCaller // Read-only binding to the contract + GatewayEVMEchidnaTestTransactor // Write-only binding to the contract + GatewayEVMEchidnaTestFilterer // Log filterer for contract events +} + +// GatewayEVMEchidnaTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayEVMEchidnaTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMEchidnaTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayEVMEchidnaTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMEchidnaTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayEVMEchidnaTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMEchidnaTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayEVMEchidnaTestSession struct { + Contract *GatewayEVMEchidnaTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMEchidnaTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayEVMEchidnaTestCallerSession struct { + Contract *GatewayEVMEchidnaTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayEVMEchidnaTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayEVMEchidnaTestTransactorSession struct { + Contract *GatewayEVMEchidnaTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMEchidnaTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayEVMEchidnaTestRaw struct { + Contract *GatewayEVMEchidnaTest // Generic contract binding to access the raw methods on +} + +// GatewayEVMEchidnaTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayEVMEchidnaTestCallerRaw struct { + Contract *GatewayEVMEchidnaTestCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayEVMEchidnaTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayEVMEchidnaTestTransactorRaw struct { + Contract *GatewayEVMEchidnaTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayEVMEchidnaTest creates a new instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. +func NewGatewayEVMEchidnaTest(address common.Address, backend bind.ContractBackend) (*GatewayEVMEchidnaTest, error) { + contract, err := bindGatewayEVMEchidnaTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTest{GatewayEVMEchidnaTestCaller: GatewayEVMEchidnaTestCaller{contract: contract}, GatewayEVMEchidnaTestTransactor: GatewayEVMEchidnaTestTransactor{contract: contract}, GatewayEVMEchidnaTestFilterer: GatewayEVMEchidnaTestFilterer{contract: contract}}, nil +} + +// NewGatewayEVMEchidnaTestCaller creates a new read-only instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. +func NewGatewayEVMEchidnaTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMEchidnaTestCaller, error) { + contract, err := bindGatewayEVMEchidnaTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestCaller{contract: contract}, nil +} + +// NewGatewayEVMEchidnaTestTransactor creates a new write-only instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. +func NewGatewayEVMEchidnaTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMEchidnaTestTransactor, error) { + contract, err := bindGatewayEVMEchidnaTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestTransactor{contract: contract}, nil +} + +// NewGatewayEVMEchidnaTestFilterer creates a new log filterer instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. +func NewGatewayEVMEchidnaTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMEchidnaTestFilterer, error) { + contract, err := bindGatewayEVMEchidnaTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestFilterer{contract: contract}, nil +} + +// bindGatewayEVMEchidnaTest binds a generic wrapper to an already deployed contract. +func bindGatewayEVMEchidnaTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayEVMEchidnaTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMEchidnaTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.contract.Transact(opts, method, params...) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "custody") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Custody() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.Custody(&_GatewayEVMEchidnaTest.CallOpts) +} + +// Custody is a free data retrieval call binding the contract method 0xdda79b75. +// +// Solidity: function custody() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) Custody() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.Custody(&_GatewayEVMEchidnaTest.CallOpts) +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) EchidnaCaller(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "echidnaCaller") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) EchidnaCaller() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.EchidnaCaller(&_GatewayEVMEchidnaTest.CallOpts) +} + +// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. +// +// Solidity: function echidnaCaller() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) EchidnaCaller() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.EchidnaCaller(&_GatewayEVMEchidnaTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Owner() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.Owner(&_GatewayEVMEchidnaTest.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) Owner() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.Owner(&_GatewayEVMEchidnaTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "proxiableUUID") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVMEchidnaTest.Contract.ProxiableUUID(&_GatewayEVMEchidnaTest.CallOpts) +} + +// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. +// +// Solidity: function proxiableUUID() view returns(bytes32) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) ProxiableUUID() ([32]byte, error) { + return _GatewayEVMEchidnaTest.Contract.ProxiableUUID(&_GatewayEVMEchidnaTest.CallOpts) +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) TestERC20(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "testERC20") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TestERC20() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.TestERC20(&_GatewayEVMEchidnaTest.CallOpts) +} + +// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. +// +// Solidity: function testERC20() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) TestERC20() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.TestERC20(&_GatewayEVMEchidnaTest.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "tssAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TssAddress() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.TssAddress(&_GatewayEVMEchidnaTest.CallOpts) +} + +// TssAddress is a free data retrieval call binding the contract method 0x5b112591. +// +// Solidity: function tssAddress() view returns(address) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) TssAddress() (common.Address, error) { + return _GatewayEVMEchidnaTest.Contract.TssAddress(&_GatewayEVMEchidnaTest.CallOpts) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Call(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "call", receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Call(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Call(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Deposit(opts *bind.TransactOpts, receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "deposit", receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Deposit(&_GatewayEVMEchidnaTest.TransactOpts, receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Deposit(&_GatewayEVMEchidnaTest.TransactOpts, receiver) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Deposit0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "deposit0", receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Deposit0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Deposit0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) DepositAndCall(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "depositAndCall", receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.DepositAndCall(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.DepositAndCall(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) DepositAndCall0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "depositAndCall0", receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.DepositAndCall0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.DepositAndCall0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset, payload) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "execute", destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Execute(&_GatewayEVMEchidnaTest.TransactOpts, destination, data) +} + +// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. +// +// Solidity: function execute(address destination, bytes data) payable returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Execute(&_GatewayEVMEchidnaTest.TransactOpts, destination, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "executeWithERC20", token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.ExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, token, to, amount, data) +} + +// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. +// +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.ExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, token, to, amount, data) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "initialize", _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Initialize(&_GatewayEVMEchidnaTest.TransactOpts, _tssAddress) +} + +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// +// Solidity: function initialize(address _tssAddress) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.Initialize(&_GatewayEVMEchidnaTest.TransactOpts, _tssAddress) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.RenounceOwnership(&_GatewayEVMEchidnaTest.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.RenounceOwnership(&_GatewayEVMEchidnaTest.TransactOpts) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "setCustody", _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.SetCustody(&_GatewayEVMEchidnaTest.TransactOpts, _custody) +} + +// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. +// +// Solidity: function setCustody(address _custody) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.SetCustody(&_GatewayEVMEchidnaTest.TransactOpts, _custody) +} + +// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. +// +// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) TestExecuteWithERC20(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "testExecuteWithERC20", to, amount, data) +} + +// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. +// +// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TestExecuteWithERC20(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.TestExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, to, amount, data) +} + +// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. +// +// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) TestExecuteWithERC20(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.TestExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, to, amount, data) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.TransferOwnership(&_GatewayEVMEchidnaTest.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.TransferOwnership(&_GatewayEVMEchidnaTest.TransactOpts, newOwner) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "upgradeTo", newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.UpgradeTo(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation) +} + +// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. +// +// Solidity: function upgradeTo(address newImplementation) returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.UpgradeTo(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.UpgradeToAndCall(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation, data) +} + +// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. +// +// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { + return _GatewayEVMEchidnaTest.Contract.UpgradeToAndCall(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation, data) +} + +// GatewayEVMEchidnaTestAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestAdminChangedIterator struct { + Event *GatewayEVMEchidnaTestAdminChanged // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestAdminChangedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestAdminChanged) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestAdminChangedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestAdminChangedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestAdminChanged represents a AdminChanged event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestAdminChanged struct { + PreviousAdmin common.Address + NewAdmin common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayEVMEchidnaTestAdminChangedIterator, error) { + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestAdminChangedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil +} + +// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestAdminChanged) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "AdminChanged") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestAdminChanged) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "AdminChanged", 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 +} + +// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. +// +// Solidity: event AdminChanged(address previousAdmin, address newAdmin) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseAdminChanged(log types.Log) (*GatewayEVMEchidnaTestAdminChanged, error) { + event := new(GatewayEVMEchidnaTestAdminChanged) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestBeaconUpgradedIterator struct { + Event *GatewayEVMEchidnaTestBeaconUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestBeaconUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestBeaconUpgraded struct { + Beacon common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayEVMEchidnaTestBeaconUpgradedIterator, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestBeaconUpgradedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil +} + +// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { + + var beaconRule []interface{} + for _, beaconItem := range beacon { + beaconRule = append(beaconRule, beaconItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestBeaconUpgraded) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "BeaconUpgraded", 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 +} + +// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. +// +// Solidity: event BeaconUpgraded(address indexed beacon) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayEVMEchidnaTestBeaconUpgraded, error) { + event := new(GatewayEVMEchidnaTestBeaconUpgraded) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestCallIterator struct { + Event *GatewayEVMEchidnaTestCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestCall represents a Call event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestCall struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMEchidnaTestCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestCallIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestCall) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseCall(log types.Log) (*GatewayEVMEchidnaTestCall, error) { + event := new(GatewayEVMEchidnaTestCall) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestDepositIterator struct { + Event *GatewayEVMEchidnaTestDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestDeposit represents a Deposit event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMEchidnaTestDepositIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestDepositIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestDeposit) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseDeposit(log types.Log) (*GatewayEVMEchidnaTestDeposit, error) { + event := new(GatewayEVMEchidnaTestDeposit) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestExecutedIterator struct { + Event *GatewayEVMEchidnaTestExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestExecuted represents a Executed event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMEchidnaTestExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestExecutedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestExecuted) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseExecuted(log types.Log) (*GatewayEVMEchidnaTestExecuted, error) { + event := new(GatewayEVMEchidnaTestExecuted) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestExecutedWithERC20Iterator struct { + Event *GatewayEVMEchidnaTestExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMEchidnaTestExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestExecutedWithERC20Iterator{contract: _GatewayEVMEchidnaTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestExecutedWithERC20) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMEchidnaTestExecutedWithERC20, error) { + event := new(GatewayEVMEchidnaTestExecutedWithERC20) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestInitializedIterator struct { + Event *GatewayEVMEchidnaTestInitialized // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestInitializedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestInitialized) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestInitialized represents a Initialized event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMEchidnaTestInitializedIterator, error) { + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestInitializedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestInitialized) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestInitialized) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseInitialized(log types.Log) (*GatewayEVMEchidnaTestInitialized, error) { + event := new(GatewayEVMEchidnaTestInitialized) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestOwnershipTransferredIterator struct { + Event *GatewayEVMEchidnaTestOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMEchidnaTestOwnershipTransferredIterator, 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 := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestOwnershipTransferredIterator{contract: _GatewayEVMEchidnaTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestOwnershipTransferred, 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 := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestOwnershipTransferred) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMEchidnaTestOwnershipTransferred, error) { + event := new(GatewayEVMEchidnaTestOwnershipTransferred) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMEchidnaTestUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestUpgradedIterator struct { + Event *GatewayEVMEchidnaTestUpgraded // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMEchidnaTestUpgradedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMEchidnaTestUpgraded) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMEchidnaTestUpgradedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMEchidnaTestUpgradedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMEchidnaTestUpgraded represents a Upgraded event raised by the GatewayEVMEchidnaTest contract. +type GatewayEVMEchidnaTestUpgraded struct { + Implementation common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayEVMEchidnaTestUpgradedIterator, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return &GatewayEVMEchidnaTestUpgradedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil +} + +// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestUpgraded, implementation []common.Address) (event.Subscription, error) { + + var implementationRule []interface{} + for _, implementationItem := range implementation { + implementationRule = append(implementationRule, implementationItem) + } + + logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Upgraded", implementationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMEchidnaTestUpgraded) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. +// +// Solidity: event Upgraded(address indexed implementation) +func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseUpgraded(log types.Log) (*GatewayEVMEchidnaTestUpgraded, error) { + event := new(GatewayEVMEchidnaTestUpgraded) + if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Upgraded", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/scripts/readme.md b/scripts/readme.md index ecc0a0ef..447e1d99 100644 --- a/scripts/readme.md +++ b/scripts/readme.md @@ -8,3 +8,8 @@ yarn localnet This will run hardhat local node and worker script, which will deploy all contracts, and listen and react to events, facilitating communication between contracts. Tasks to interact with localnet are located in `tasks/localnet`. To make use of default contract addresses on localnet, start localnet from scratch, so contracts are deployed on same addresses. Otherwise, provide custom addresses as tasks parameters. + +To only show logs from `WORKER`: +``` +yarn localnet --hide="NODE" +``` \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.ts b/typechain-types/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.ts new file mode 100644 index 00000000..7f3451e7 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.ts @@ -0,0 +1,331 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ERC20CustodyNewEchidnaTestInterface extends utils.Interface { + functions: { + "echidnaCaller()": FunctionFragment; + "gateway()": FunctionFragment; + "testERC20()": FunctionFragment; + "testWithdrawAndCall(address,uint256,bytes)": FunctionFragment; + "withdraw(address,address,uint256)": FunctionFragment; + "withdrawAndCall(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "echidnaCaller" + | "gateway" + | "testERC20" + | "testWithdrawAndCall" + | "withdraw" + | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "echidnaCaller", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData(functionFragment: "testERC20", values?: undefined): string; + encodeFunctionData( + functionFragment: "testWithdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "echidnaCaller", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "testERC20", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "testWithdrawAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: { + "Withdraw(address,address,uint256)": EventFragment; + "WithdrawAndCall(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + token: string; + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ERC20CustodyNewEchidnaTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ERC20CustodyNewEchidnaTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + echidnaCaller(overrides?: CallOverrides): Promise<[string]>; + + gateway(overrides?: CallOverrides): Promise<[string]>; + + testERC20(overrides?: CallOverrides): Promise<[string]>; + + testWithdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + echidnaCaller(overrides?: CallOverrides): Promise; + + gateway(overrides?: CallOverrides): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testWithdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + echidnaCaller(overrides?: CallOverrides): Promise; + + gateway(overrides?: CallOverrides): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testWithdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Withdraw(address,address,uint256)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + echidnaCaller(overrides?: CallOverrides): Promise; + + gateway(overrides?: CallOverrides): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testWithdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + echidnaCaller(overrides?: CallOverrides): Promise; + + gateway(overrides?: CallOverrides): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testWithdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVMEchidnaTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVMEchidnaTest.ts new file mode 100644 index 00000000..5a7945e3 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVMEchidnaTest.ts @@ -0,0 +1,935 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface GatewayEVMEchidnaTestInterface extends utils.Interface { + functions: { + "call(address,bytes)": FunctionFragment; + "custody()": FunctionFragment; + "deposit(address)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall(address,bytes)": FunctionFragment; + "depositAndCall(address,uint256,address,bytes)": FunctionFragment; + "echidnaCaller()": FunctionFragment; + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + "initialize(address)": FunctionFragment; + "owner()": FunctionFragment; + "proxiableUUID()": FunctionFragment; + "renounceOwnership()": FunctionFragment; + "setCustody(address)": FunctionFragment; + "testERC20()": FunctionFragment; + "testExecuteWithERC20(address,uint256,bytes)": FunctionFragment; + "transferOwnership(address)": FunctionFragment; + "tssAddress()": FunctionFragment; + "upgradeTo(address)": FunctionFragment; + "upgradeToAndCall(address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "call" + | "custody" + | "deposit(address)" + | "deposit(address,uint256,address)" + | "depositAndCall(address,bytes)" + | "depositAndCall(address,uint256,address,bytes)" + | "echidnaCaller" + | "execute" + | "executeWithERC20" + | "initialize" + | "owner" + | "proxiableUUID" + | "renounceOwnership" + | "setCustody" + | "testERC20" + | "testExecuteWithERC20" + | "transferOwnership" + | "tssAddress" + | "upgradeTo" + | "upgradeToAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deposit(address,uint256,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "echidnaCaller", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "owner", values?: undefined): string; + encodeFunctionData( + functionFragment: "proxiableUUID", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "renounceOwnership", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "setCustody", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "testERC20", values?: undefined): string; + encodeFunctionData( + functionFragment: "testExecuteWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "transferOwnership", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tssAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "upgradeTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "upgradeToAndCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "deposit(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deposit(address,uint256,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "echidnaCaller", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "proxiableUUID", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "renounceOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "testERC20", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "testExecuteWithERC20", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferOwnership", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "tssAddress", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "upgradeTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "upgradeToAndCall", + data: BytesLike + ): Result; + + events: { + "AdminChanged(address,address)": EventFragment; + "BeaconUpgraded(address)": EventFragment; + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "Initialized(uint8)": EventFragment; + "OwnershipTransferred(address,address)": EventFragment; + "Upgraded(address)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; + getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; + getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; +} + +export interface AdminChangedEventObject { + previousAdmin: string; + newAdmin: string; +} +export type AdminChangedEvent = TypedEvent< + [string, string], + AdminChangedEventObject +>; + +export type AdminChangedEventFilter = TypedEventFilter; + +export interface BeaconUpgradedEventObject { + beacon: string; +} +export type BeaconUpgradedEvent = TypedEvent< + [string], + BeaconUpgradedEventObject +>; + +export type BeaconUpgradedEventFilter = TypedEventFilter; + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface InitializedEventObject { + version: number; +} +export type InitializedEvent = TypedEvent<[number], InitializedEventObject>; + +export type InitializedEventFilter = TypedEventFilter; + +export interface OwnershipTransferredEventObject { + previousOwner: string; + newOwner: string; +} +export type OwnershipTransferredEvent = TypedEvent< + [string, string], + OwnershipTransferredEventObject +>; + +export type OwnershipTransferredEventFilter = + TypedEventFilter; + +export interface UpgradedEventObject { + implementation: string; +} +export type UpgradedEvent = TypedEvent<[string], UpgradedEventObject>; + +export type UpgradedEventFilter = TypedEventFilter; + +export interface GatewayEVMEchidnaTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMEchidnaTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise<[string]>; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + echidnaCaller(overrides?: CallOverrides): Promise<[string]>; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise<[string]>; + + proxiableUUID(overrides?: CallOverrides): Promise<[string]>; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + testERC20(overrides?: CallOverrides): Promise<[string]>; + + testExecuteWithERC20( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise<[string]>; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + echidnaCaller(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testExecuteWithERC20( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + echidnaCaller(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership(overrides?: CallOverrides): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testExecuteWithERC20( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "AdminChanged(address,address)"( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + AdminChanged( + previousAdmin?: null, + newAdmin?: null + ): AdminChangedEventFilter; + + "BeaconUpgraded(address)"( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + BeaconUpgraded( + beacon?: PromiseOrValue | null + ): BeaconUpgradedEventFilter; + + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "Initialized(uint8)"(version?: null): InitializedEventFilter; + Initialized(version?: null): InitializedEventFilter; + + "OwnershipTransferred(address,address)"( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + OwnershipTransferred( + previousOwner?: PromiseOrValue | null, + newOwner?: PromiseOrValue | null + ): OwnershipTransferredEventFilter; + + "Upgraded(address)"( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + Upgraded( + implementation?: PromiseOrValue | null + ): UpgradedEventFilter; + }; + + estimateGas: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + echidnaCaller(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testExecuteWithERC20( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + custody(overrides?: CallOverrides): Promise; + + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + echidnaCaller(overrides?: CallOverrides): Promise; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + initialize( + _tssAddress: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + owner(overrides?: CallOverrides): Promise; + + proxiableUUID(overrides?: CallOverrides): Promise; + + renounceOwnership( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setCustody( + _custody: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + testERC20(overrides?: CallOverrides): Promise; + + testExecuteWithERC20( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferOwnership( + newOwner: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + tssAddress(overrides?: CallOverrides): Promise; + + upgradeTo( + newImplementation: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + upgradeToAndCall( + newImplementation: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 939b9af8..cc5d7d54 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -4,7 +4,9 @@ import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; +export type { ERC20CustodyNewEchidnaTest } from "./ERC20CustodyNewEchidnaTest"; export type { GatewayEVM } from "./GatewayEVM"; +export type { GatewayEVMEchidnaTest } from "./GatewayEVMEchidnaTest"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory.ts new file mode 100644 index 00000000..498c7549 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory.ts @@ -0,0 +1,246 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ERC20CustodyNewEchidnaTest, + ERC20CustodyNewEchidnaTestInterface, +} from "../../../../contracts/prototypes/evm/ERC20CustodyNewEchidnaTest"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "echidnaCaller", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "testERC20", + outputs: [ + { + internalType: "contract TestERC20", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "testWithdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ERC20CustodyNewEchidnaTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ERC20CustodyNewEchidnaTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ERC20CustodyNewEchidnaTest__factory extends ContractFactory { + constructor(...args: ERC20CustodyNewEchidnaTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): ERC20CustodyNewEchidnaTest { + return super.attach(address) as ERC20CustodyNewEchidnaTest; + } + override connect(signer: Signer): ERC20CustodyNewEchidnaTest__factory { + return super.connect(signer) as ERC20CustodyNewEchidnaTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ERC20CustodyNewEchidnaTestInterface { + return new utils.Interface(_abi) as ERC20CustodyNewEchidnaTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ERC20CustodyNewEchidnaTest { + return new Contract( + address, + _abi, + signerOrProvider + ) as ERC20CustodyNewEchidnaTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index bb608540..b3701baa 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -149,7 +149,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory.ts new file mode 100644 index 00000000..8f1ef1a7 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory.ts @@ -0,0 +1,638 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + GatewayEVMEchidnaTest, + GatewayEVMEchidnaTestInterface, +} from "../../../../contracts/prototypes/evm/GatewayEVMEchidnaTest"; + +const _abi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "previousAdmin", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "newAdmin", + type: "address", + }, + ], + name: "AdminChanged", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "beacon", + type: "address", + }, + ], + name: "BeaconUpgraded", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint8", + name: "version", + type: "uint8", + }, + ], + name: "Initialized", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "previousOwner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "OwnershipTransferred", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "custody", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "asset", + type: "address", + }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "echidnaCaller", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_tssAddress", + type: "address", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "owner", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "proxiableUUID", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "renounceOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_custody", + type: "address", + }, + ], + name: "setCustody", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "testERC20", + outputs: [ + { + internalType: "contract TestERC20", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "testExecuteWithERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newOwner", + type: "address", + }, + ], + name: "transferOwnership", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "tssAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + ], + name: "upgradeTo", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newImplementation", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "upgradeToAndCall", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMEchidnaTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMEchidnaTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVMEchidnaTest__factory extends ContractFactory { + constructor(...args: GatewayEVMEchidnaTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVMEchidnaTest { + return super.attach(address) as GatewayEVMEchidnaTest; + } + override connect(signer: Signer): GatewayEVMEchidnaTest__factory { + return super.connect(signer) as GatewayEVMEchidnaTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMEchidnaTestInterface { + return new utils.Interface(_abi) as GatewayEVMEchidnaTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVMEchidnaTest { + return new Contract( + address, + _abi, + signerOrProvider + ) as GatewayEVMEchidnaTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 39557383..de37e8d2 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -20,6 +20,11 @@ const _abi = [ name: "ApprovalFailed", type: "error", }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, { inputs: [], name: "DepositFailed", @@ -530,7 +535,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index b7a35400..bba4f1fc 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -3,7 +3,9 @@ /* eslint-disable */ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; +export { ERC20CustodyNewEchidnaTest__factory } from "./ERC20CustodyNewEchidnaTest__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; +export { GatewayEVMEchidnaTest__factory } from "./GatewayEVMEchidnaTest__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 6f78440d..d1871412 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -336,10 +336,18 @@ declare module "hardhat/types/runtime" { name: "ERC20CustodyNew", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ERC20CustodyNewEchidnaTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayEVMEchidnaTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayEVMUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions @@ -854,11 +862,21 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ERC20CustodyNewEchidnaTest", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayEVM", address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayEVMEchidnaTest", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayEVMUpgradeTest", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index f17533ca..94768cb5 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -158,8 +158,12 @@ export type { ZetaConnectorNonEth } from "./contracts/evm/ZetaConnector.non-eth. export { ZetaConnectorNonEth__factory } from "./factories/contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth__factory"; export type { ERC20CustodyNew } from "./contracts/prototypes/evm/ERC20CustodyNew"; export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNew__factory"; +export type { ERC20CustodyNewEchidnaTest } from "./contracts/prototypes/evm/ERC20CustodyNewEchidnaTest"; +export { ERC20CustodyNewEchidnaTest__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory"; export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; +export type { GatewayEVMEchidnaTest } from "./contracts/prototypes/evm/GatewayEVMEchidnaTest"; +export { GatewayEVMEchidnaTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory"; export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; From 354e45a1ec47c3aac7ee502bfba09fab7e910d04 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 4 Jul 2024 22:43:53 +0200 Subject: [PATCH 56/86] move to test folder --- echidna.yaml | 6 +- .../erc20custodynewechidnatest.go | 668 ------ .../gatewayevmechidnatest.go | 2004 ----------------- .../fuzz}/ERC20CustodyNewEchidnaTest.sol | 7 +- .../fuzz}/GatewayEVMEchidnaTest.sol | 7 +- test/fuzz/readme.md | 13 + .../contracts/prototypes/evm/index.ts | 2 - .../contracts/prototypes/evm/index.ts | 2 - typechain-types/hardhat.d.ts | 18 - typechain-types/index.ts | 4 - 10 files changed, 21 insertions(+), 2710 deletions(-) delete mode 100644 pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go delete mode 100644 pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go rename {contracts/prototypes/evm => test/fuzz}/ERC20CustodyNewEchidnaTest.sol (85%) rename {contracts/prototypes/evm => test/fuzz}/GatewayEVMEchidnaTest.sol (82%) create mode 100644 test/fuzz/readme.md diff --git a/echidna.yaml b/echidna.yaml index 6f1c0d64..a7bce751 100644 --- a/echidna.yaml +++ b/echidna.yaml @@ -1,8 +1,6 @@ # provide solc remappings to crytic-compile cryticArgs: ['--solc-remaps', '@=node_modules/@'] testMode: "assertion" -coverage: true -testLimit: 100000 +testLimit: 50000 seqLen: 10000 -allContracts: false -codeSize: 0x12000 \ No newline at end of file +allContracts: false \ No newline at end of file diff --git a/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go b/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go deleted file mode 100644 index df810b7f..00000000 --- a/pkg/contracts/prototypes/evm/erc20custodynewechidnatest.sol/erc20custodynewechidnatest.go +++ /dev/null @@ -1,668 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package erc20custodynewechidnatest - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ERC20CustodyNewEchidnaTestMetaData contains all meta data concerning the ERC20CustodyNewEchidnaTest contract. -var ERC20CustodyNewEchidnaTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"echidnaCaller\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testERC20\",\"outputs\":[{\"internalType\":\"contractTestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"testWithdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", -} - -// ERC20CustodyNewEchidnaTestABI is the input ABI used to generate the binding from. -// Deprecated: Use ERC20CustodyNewEchidnaTestMetaData.ABI instead. -var ERC20CustodyNewEchidnaTestABI = ERC20CustodyNewEchidnaTestMetaData.ABI - -// ERC20CustodyNewEchidnaTestBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ERC20CustodyNewEchidnaTestMetaData.Bin instead. -var ERC20CustodyNewEchidnaTestBin = ERC20CustodyNewEchidnaTestMetaData.Bin - -// DeployERC20CustodyNewEchidnaTest deploys a new Ethereum contract, binding an instance of ERC20CustodyNewEchidnaTest to it. -func DeployERC20CustodyNewEchidnaTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20CustodyNewEchidnaTest, error) { - parsed, err := ERC20CustodyNewEchidnaTestMetaData.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(ERC20CustodyNewEchidnaTestBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ERC20CustodyNewEchidnaTest{ERC20CustodyNewEchidnaTestCaller: ERC20CustodyNewEchidnaTestCaller{contract: contract}, ERC20CustodyNewEchidnaTestTransactor: ERC20CustodyNewEchidnaTestTransactor{contract: contract}, ERC20CustodyNewEchidnaTestFilterer: ERC20CustodyNewEchidnaTestFilterer{contract: contract}}, nil -} - -// ERC20CustodyNewEchidnaTest is an auto generated Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTest struct { - ERC20CustodyNewEchidnaTestCaller // Read-only binding to the contract - ERC20CustodyNewEchidnaTestTransactor // Write-only binding to the contract - ERC20CustodyNewEchidnaTestFilterer // Log filterer for contract events -} - -// ERC20CustodyNewEchidnaTestCaller is an auto generated read-only Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTestCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ERC20CustodyNewEchidnaTestTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTestTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ERC20CustodyNewEchidnaTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ERC20CustodyNewEchidnaTestFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ERC20CustodyNewEchidnaTestSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ERC20CustodyNewEchidnaTestSession struct { - Contract *ERC20CustodyNewEchidnaTest // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ERC20CustodyNewEchidnaTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ERC20CustodyNewEchidnaTestCallerSession struct { - Contract *ERC20CustodyNewEchidnaTestCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ERC20CustodyNewEchidnaTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ERC20CustodyNewEchidnaTestTransactorSession struct { - Contract *ERC20CustodyNewEchidnaTestTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ERC20CustodyNewEchidnaTestRaw is an auto generated low-level Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTestRaw struct { - Contract *ERC20CustodyNewEchidnaTest // Generic contract binding to access the raw methods on -} - -// ERC20CustodyNewEchidnaTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTestCallerRaw struct { - Contract *ERC20CustodyNewEchidnaTestCaller // Generic read-only contract binding to access the raw methods on -} - -// ERC20CustodyNewEchidnaTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ERC20CustodyNewEchidnaTestTransactorRaw struct { - Contract *ERC20CustodyNewEchidnaTestTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewERC20CustodyNewEchidnaTest creates a new instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. -func NewERC20CustodyNewEchidnaTest(address common.Address, backend bind.ContractBackend) (*ERC20CustodyNewEchidnaTest, error) { - contract, err := bindERC20CustodyNewEchidnaTest(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTest{ERC20CustodyNewEchidnaTestCaller: ERC20CustodyNewEchidnaTestCaller{contract: contract}, ERC20CustodyNewEchidnaTestTransactor: ERC20CustodyNewEchidnaTestTransactor{contract: contract}, ERC20CustodyNewEchidnaTestFilterer: ERC20CustodyNewEchidnaTestFilterer{contract: contract}}, nil -} - -// NewERC20CustodyNewEchidnaTestCaller creates a new read-only instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. -func NewERC20CustodyNewEchidnaTestCaller(address common.Address, caller bind.ContractCaller) (*ERC20CustodyNewEchidnaTestCaller, error) { - contract, err := bindERC20CustodyNewEchidnaTest(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTestCaller{contract: contract}, nil -} - -// NewERC20CustodyNewEchidnaTestTransactor creates a new write-only instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. -func NewERC20CustodyNewEchidnaTestTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20CustodyNewEchidnaTestTransactor, error) { - contract, err := bindERC20CustodyNewEchidnaTest(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTestTransactor{contract: contract}, nil -} - -// NewERC20CustodyNewEchidnaTestFilterer creates a new log filterer instance of ERC20CustodyNewEchidnaTest, bound to a specific deployed contract. -func NewERC20CustodyNewEchidnaTestFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20CustodyNewEchidnaTestFilterer, error) { - contract, err := bindERC20CustodyNewEchidnaTest(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTestFilterer{contract: contract}, nil -} - -// bindERC20CustodyNewEchidnaTest binds a generic wrapper to an already deployed contract. -func bindERC20CustodyNewEchidnaTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ERC20CustodyNewEchidnaTestMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.ERC20CustodyNewEchidnaTestTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ERC20CustodyNewEchidnaTest.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.contract.Transact(opts, method, params...) -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) EchidnaCaller(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "echidnaCaller") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) EchidnaCaller() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.EchidnaCaller(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) EchidnaCaller() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.EchidnaCaller(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "gateway") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) Gateway() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.Gateway(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) Gateway() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.Gateway(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCaller) TestERC20(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ERC20CustodyNewEchidnaTest.contract.Call(opts, &out, "testERC20") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) TestERC20() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.TestERC20(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestCallerSession) TestERC20() (common.Address, error) { - return _ERC20CustodyNewEchidnaTest.Contract.TestERC20(&_ERC20CustodyNewEchidnaTest.CallOpts) -} - -// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. -// -// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) TestWithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "testWithdrawAndCall", to, amount, data) -} - -// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. -// -// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) TestWithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.TestWithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, to, amount, data) -} - -// TestWithdrawAndCall is a paid mutator transaction binding the contract method 0x6133b4bb. -// -// Solidity: function testWithdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) TestWithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.TestWithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, to, amount, data) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address token, address to, uint256 amount) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) Withdraw(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "withdraw", token, to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address token, address to, uint256 amount) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.Withdraw(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xd9caed12. -// -// Solidity: function withdraw(address token, address to, uint256 amount) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) Withdraw(token common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.Withdraw(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. -// -// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactor) WithdrawAndCall(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.contract.Transact(opts, "withdrawAndCall", token, to, amount, data) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. -// -// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.WithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount, data) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x21fc65f2. -// -// Solidity: function withdrawAndCall(address token, address to, uint256 amount, bytes data) returns() -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestTransactorSession) WithdrawAndCall(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ERC20CustodyNewEchidnaTest.Contract.WithdrawAndCall(&_ERC20CustodyNewEchidnaTest.TransactOpts, token, to, amount, data) -} - -// ERC20CustodyNewEchidnaTestWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ERC20CustodyNewEchidnaTest contract. -type ERC20CustodyNewEchidnaTestWithdrawIterator struct { - Event *ERC20CustodyNewEchidnaTestWithdraw // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ERC20CustodyNewEchidnaTestWithdraw) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ERC20CustodyNewEchidnaTestWithdraw) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ERC20CustodyNewEchidnaTestWithdrawIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ERC20CustodyNewEchidnaTestWithdraw represents a Withdraw event raised by the ERC20CustodyNewEchidnaTest contract. -type ERC20CustodyNewEchidnaTestWithdraw struct { - Token common.Address - To common.Address - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdraw is a free log retrieval operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. -// -// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) FilterWithdraw(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewEchidnaTestWithdrawIterator, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.FilterLogs(opts, "Withdraw", tokenRule, toRule) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTestWithdrawIterator{contract: _ERC20CustodyNewEchidnaTest.contract, event: "Withdraw", logs: logs, sub: sub}, nil -} - -// WatchWithdraw is a free log subscription operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. -// -// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewEchidnaTestWithdraw, token []common.Address, to []common.Address) (event.Subscription, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.WatchLogs(opts, "Withdraw", tokenRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ERC20CustodyNewEchidnaTestWithdraw) - if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "Withdraw", 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 -} - -// ParseWithdraw is a log parse operation binding the contract event 0x9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb. -// -// Solidity: event Withdraw(address indexed token, address indexed to, uint256 amount) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) ParseWithdraw(log types.Log) (*ERC20CustodyNewEchidnaTestWithdraw, error) { - event := new(ERC20CustodyNewEchidnaTestWithdraw) - if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "Withdraw", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ERC20CustodyNewEchidnaTestWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ERC20CustodyNewEchidnaTest contract. -type ERC20CustodyNewEchidnaTestWithdrawAndCallIterator struct { - Event *ERC20CustodyNewEchidnaTestWithdrawAndCall // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ERC20CustodyNewEchidnaTestWithdrawAndCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ERC20CustodyNewEchidnaTestWithdrawAndCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ERC20CustodyNewEchidnaTestWithdrawAndCallIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ERC20CustodyNewEchidnaTestWithdrawAndCall represents a WithdrawAndCall event raised by the ERC20CustodyNewEchidnaTest contract. -type ERC20CustodyNewEchidnaTestWithdrawAndCall struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. -// -// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*ERC20CustodyNewEchidnaTestWithdrawAndCallIterator, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.FilterLogs(opts, "WithdrawAndCall", tokenRule, toRule) - if err != nil { - return nil, err - } - return &ERC20CustodyNewEchidnaTestWithdrawAndCallIterator{contract: _ERC20CustodyNewEchidnaTest.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil -} - -// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. -// -// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ERC20CustodyNewEchidnaTestWithdrawAndCall, token []common.Address, to []common.Address) (event.Subscription, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ERC20CustodyNewEchidnaTest.contract.WatchLogs(opts, "WithdrawAndCall", tokenRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ERC20CustodyNewEchidnaTestWithdrawAndCall) - if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "WithdrawAndCall", 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 -} - -// ParseWithdrawAndCall is a log parse operation binding the contract event 0x85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e. -// -// Solidity: event WithdrawAndCall(address indexed token, address indexed to, uint256 amount, bytes data) -func (_ERC20CustodyNewEchidnaTest *ERC20CustodyNewEchidnaTestFilterer) ParseWithdrawAndCall(log types.Log) (*ERC20CustodyNewEchidnaTestWithdrawAndCall, error) { - event := new(ERC20CustodyNewEchidnaTestWithdrawAndCall) - if err := _ERC20CustodyNewEchidnaTest.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go b/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go deleted file mode 100644 index 065da1ef..00000000 --- a/pkg/contracts/prototypes/evm/gatewayevmechidnatest.sol/gatewayevmechidnatest.go +++ /dev/null @@ -1,2004 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package gatewayevmechidnatest - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// GatewayEVMEchidnaTestMetaData contains all meta data concerning the GatewayEVMEchidnaTest contract. -var GatewayEVMEchidnaTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"echidnaCaller\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testERC20\",\"outputs\":[{\"internalType\":\"contractTestERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"testExecuteWithERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", -} - -// GatewayEVMEchidnaTestABI is the input ABI used to generate the binding from. -// Deprecated: Use GatewayEVMEchidnaTestMetaData.ABI instead. -var GatewayEVMEchidnaTestABI = GatewayEVMEchidnaTestMetaData.ABI - -// GatewayEVMEchidnaTestBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayEVMEchidnaTestMetaData.Bin instead. -var GatewayEVMEchidnaTestBin = GatewayEVMEchidnaTestMetaData.Bin - -// DeployGatewayEVMEchidnaTest deploys a new Ethereum contract, binding an instance of GatewayEVMEchidnaTest to it. -func DeployGatewayEVMEchidnaTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVMEchidnaTest, error) { - parsed, err := GatewayEVMEchidnaTestMetaData.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(GatewayEVMEchidnaTestBin), backend) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &GatewayEVMEchidnaTest{GatewayEVMEchidnaTestCaller: GatewayEVMEchidnaTestCaller{contract: contract}, GatewayEVMEchidnaTestTransactor: GatewayEVMEchidnaTestTransactor{contract: contract}, GatewayEVMEchidnaTestFilterer: GatewayEVMEchidnaTestFilterer{contract: contract}}, nil -} - -// GatewayEVMEchidnaTest is an auto generated Go binding around an Ethereum contract. -type GatewayEVMEchidnaTest struct { - GatewayEVMEchidnaTestCaller // Read-only binding to the contract - GatewayEVMEchidnaTestTransactor // Write-only binding to the contract - GatewayEVMEchidnaTestFilterer // Log filterer for contract events -} - -// GatewayEVMEchidnaTestCaller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayEVMEchidnaTestCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayEVMEchidnaTestTransactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayEVMEchidnaTestTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayEVMEchidnaTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayEVMEchidnaTestFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// GatewayEVMEchidnaTestSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type GatewayEVMEchidnaTestSession struct { - Contract *GatewayEVMEchidnaTest // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayEVMEchidnaTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type GatewayEVMEchidnaTestCallerSession struct { - Contract *GatewayEVMEchidnaTestCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// GatewayEVMEchidnaTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type GatewayEVMEchidnaTestTransactorSession struct { - Contract *GatewayEVMEchidnaTestTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// GatewayEVMEchidnaTestRaw is an auto generated low-level Go binding around an Ethereum contract. -type GatewayEVMEchidnaTestRaw struct { - Contract *GatewayEVMEchidnaTest // Generic contract binding to access the raw methods on -} - -// GatewayEVMEchidnaTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type GatewayEVMEchidnaTestCallerRaw struct { - Contract *GatewayEVMEchidnaTestCaller // Generic read-only contract binding to access the raw methods on -} - -// GatewayEVMEchidnaTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type GatewayEVMEchidnaTestTransactorRaw struct { - Contract *GatewayEVMEchidnaTestTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewGatewayEVMEchidnaTest creates a new instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. -func NewGatewayEVMEchidnaTest(address common.Address, backend bind.ContractBackend) (*GatewayEVMEchidnaTest, error) { - contract, err := bindGatewayEVMEchidnaTest(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTest{GatewayEVMEchidnaTestCaller: GatewayEVMEchidnaTestCaller{contract: contract}, GatewayEVMEchidnaTestTransactor: GatewayEVMEchidnaTestTransactor{contract: contract}, GatewayEVMEchidnaTestFilterer: GatewayEVMEchidnaTestFilterer{contract: contract}}, nil -} - -// NewGatewayEVMEchidnaTestCaller creates a new read-only instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. -func NewGatewayEVMEchidnaTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMEchidnaTestCaller, error) { - contract, err := bindGatewayEVMEchidnaTest(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestCaller{contract: contract}, nil -} - -// NewGatewayEVMEchidnaTestTransactor creates a new write-only instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. -func NewGatewayEVMEchidnaTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMEchidnaTestTransactor, error) { - contract, err := bindGatewayEVMEchidnaTest(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestTransactor{contract: contract}, nil -} - -// NewGatewayEVMEchidnaTestFilterer creates a new log filterer instance of GatewayEVMEchidnaTest, bound to a specific deployed contract. -func NewGatewayEVMEchidnaTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMEchidnaTestFilterer, error) { - contract, err := bindGatewayEVMEchidnaTest(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestFilterer{contract: contract}, nil -} - -// bindGatewayEVMEchidnaTest binds a generic wrapper to an already deployed contract. -func bindGatewayEVMEchidnaTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := GatewayEVMEchidnaTestMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.GatewayEVMEchidnaTestTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayEVMEchidnaTest.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.contract.Transact(opts, method, params...) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) Custody(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "custody") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Custody() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.Custody(&_GatewayEVMEchidnaTest.CallOpts) -} - -// Custody is a free data retrieval call binding the contract method 0xdda79b75. -// -// Solidity: function custody() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) Custody() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.Custody(&_GatewayEVMEchidnaTest.CallOpts) -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) EchidnaCaller(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "echidnaCaller") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) EchidnaCaller() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.EchidnaCaller(&_GatewayEVMEchidnaTest.CallOpts) -} - -// EchidnaCaller is a free data retrieval call binding the contract method 0x81100bf0. -// -// Solidity: function echidnaCaller() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) EchidnaCaller() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.EchidnaCaller(&_GatewayEVMEchidnaTest.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) Owner(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "owner") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Owner() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.Owner(&_GatewayEVMEchidnaTest.CallOpts) -} - -// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. -// -// Solidity: function owner() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) Owner() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.Owner(&_GatewayEVMEchidnaTest.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) ProxiableUUID(opts *bind.CallOpts) ([32]byte, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "proxiableUUID") - - if err != nil { - return *new([32]byte), err - } - - out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) - - return out0, err - -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) ProxiableUUID() ([32]byte, error) { - return _GatewayEVMEchidnaTest.Contract.ProxiableUUID(&_GatewayEVMEchidnaTest.CallOpts) -} - -// ProxiableUUID is a free data retrieval call binding the contract method 0x52d1902d. -// -// Solidity: function proxiableUUID() view returns(bytes32) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) ProxiableUUID() ([32]byte, error) { - return _GatewayEVMEchidnaTest.Contract.ProxiableUUID(&_GatewayEVMEchidnaTest.CallOpts) -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) TestERC20(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "testERC20") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TestERC20() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.TestERC20(&_GatewayEVMEchidnaTest.CallOpts) -} - -// TestERC20 is a free data retrieval call binding the contract method 0x3c2f05a8. -// -// Solidity: function testERC20() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) TestERC20() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.TestERC20(&_GatewayEVMEchidnaTest.CallOpts) -} - -// TssAddress is a free data retrieval call binding the contract method 0x5b112591. -// -// Solidity: function tssAddress() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCaller) TssAddress(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _GatewayEVMEchidnaTest.contract.Call(opts, &out, "tssAddress") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// TssAddress is a free data retrieval call binding the contract method 0x5b112591. -// -// Solidity: function tssAddress() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TssAddress() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.TssAddress(&_GatewayEVMEchidnaTest.CallOpts) -} - -// TssAddress is a free data retrieval call binding the contract method 0x5b112591. -// -// Solidity: function tssAddress() view returns(address) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestCallerSession) TssAddress() (common.Address, error) { - return _GatewayEVMEchidnaTest.Contract.TssAddress(&_GatewayEVMEchidnaTest.CallOpts) -} - -// Call is a paid mutator transaction binding the contract method 0x1b8b921d. -// -// Solidity: function call(address receiver, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Call(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "call", receiver, payload) -} - -// Call is a paid mutator transaction binding the contract method 0x1b8b921d. -// -// Solidity: function call(address receiver, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Call(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) -} - -// Call is a paid mutator transaction binding the contract method 0x1b8b921d. -// -// Solidity: function call(address receiver, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Call(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) -} - -// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. -// -// Solidity: function deposit(address receiver) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Deposit(opts *bind.TransactOpts, receiver common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "deposit", receiver) -} - -// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. -// -// Solidity: function deposit(address receiver) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Deposit(receiver common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Deposit(&_GatewayEVMEchidnaTest.TransactOpts, receiver) -} - -// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. -// -// Solidity: function deposit(address receiver) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Deposit(receiver common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Deposit(&_GatewayEVMEchidnaTest.TransactOpts, receiver) -} - -// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. -// -// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Deposit0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "deposit0", receiver, amount, asset) -} - -// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. -// -// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Deposit0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset) -} - -// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. -// -// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Deposit0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset) -} - -// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. -// -// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) DepositAndCall(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "depositAndCall", receiver, payload) -} - -// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. -// -// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.DepositAndCall(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) -} - -// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. -// -// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.DepositAndCall(&_GatewayEVMEchidnaTest.TransactOpts, receiver, payload) -} - -// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. -// -// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) DepositAndCall0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "depositAndCall0", receiver, amount, asset, payload) -} - -// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. -// -// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.DepositAndCall0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset, payload) -} - -// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. -// -// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.DepositAndCall0(&_GatewayEVMEchidnaTest.TransactOpts, receiver, amount, asset, payload) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Execute(opts *bind.TransactOpts, destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "execute", destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Execute(&_GatewayEVMEchidnaTest.TransactOpts, destination, data) -} - -// Execute is a paid mutator transaction binding the contract method 0x1cff79cd. -// -// Solidity: function execute(address destination, bytes data) payable returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Execute(destination common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Execute(&_GatewayEVMEchidnaTest.TransactOpts, destination, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "executeWithERC20", token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.ExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, token, to, amount, data) -} - -// ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. -// -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.ExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, token, to, amount, data) -} - -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "initialize", _tssAddress) -} - -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Initialize(&_GatewayEVMEchidnaTest.TransactOpts, _tssAddress) -} - -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. -// -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.Initialize(&_GatewayEVMEchidnaTest.TransactOpts, _tssAddress) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "renounceOwnership") -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.RenounceOwnership(&_GatewayEVMEchidnaTest.TransactOpts) -} - -// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. -// -// Solidity: function renounceOwnership() returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) RenounceOwnership() (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.RenounceOwnership(&_GatewayEVMEchidnaTest.TransactOpts) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) SetCustody(opts *bind.TransactOpts, _custody common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "setCustody", _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.SetCustody(&_GatewayEVMEchidnaTest.TransactOpts, _custody) -} - -// SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. -// -// Solidity: function setCustody(address _custody) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) SetCustody(_custody common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.SetCustody(&_GatewayEVMEchidnaTest.TransactOpts, _custody) -} - -// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. -// -// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) TestExecuteWithERC20(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "testExecuteWithERC20", to, amount, data) -} - -// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. -// -// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TestExecuteWithERC20(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.TestExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, to, amount, data) -} - -// TestExecuteWithERC20 is a paid mutator transaction binding the contract method 0x6ab90f9b. -// -// Solidity: function testExecuteWithERC20(address to, uint256 amount, bytes data) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) TestExecuteWithERC20(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.TestExecuteWithERC20(&_GatewayEVMEchidnaTest.TransactOpts, to, amount, data) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "transferOwnership", newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.TransferOwnership(&_GatewayEVMEchidnaTest.TransactOpts, newOwner) -} - -// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. -// -// Solidity: function transferOwnership(address newOwner) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.TransferOwnership(&_GatewayEVMEchidnaTest.TransactOpts, newOwner) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) UpgradeTo(opts *bind.TransactOpts, newImplementation common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "upgradeTo", newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.UpgradeTo(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation) -} - -// UpgradeTo is a paid mutator transaction binding the contract method 0x3659cfe6. -// -// Solidity: function upgradeTo(address newImplementation) returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) UpgradeTo(newImplementation common.Address) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.UpgradeTo(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactor) UpgradeToAndCall(opts *bind.TransactOpts, newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.contract.Transact(opts, "upgradeToAndCall", newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.UpgradeToAndCall(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation, data) -} - -// UpgradeToAndCall is a paid mutator transaction binding the contract method 0x4f1ef286. -// -// Solidity: function upgradeToAndCall(address newImplementation, bytes data) payable returns() -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestTransactorSession) UpgradeToAndCall(newImplementation common.Address, data []byte) (*types.Transaction, error) { - return _GatewayEVMEchidnaTest.Contract.UpgradeToAndCall(&_GatewayEVMEchidnaTest.TransactOpts, newImplementation, data) -} - -// GatewayEVMEchidnaTestAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestAdminChangedIterator struct { - Event *GatewayEVMEchidnaTestAdminChanged // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestAdminChangedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestAdminChanged) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestAdminChangedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestAdminChangedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestAdminChanged represents a AdminChanged event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestAdminChanged struct { - PreviousAdmin common.Address - NewAdmin common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterAdminChanged is a free log retrieval operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterAdminChanged(opts *bind.FilterOpts) (*GatewayEVMEchidnaTestAdminChangedIterator, error) { - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestAdminChangedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "AdminChanged", logs: logs, sub: sub}, nil -} - -// WatchAdminChanged is a free log subscription operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchAdminChanged(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestAdminChanged) (event.Subscription, error) { - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "AdminChanged") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestAdminChanged) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "AdminChanged", 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 -} - -// ParseAdminChanged is a log parse operation binding the contract event 0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f. -// -// Solidity: event AdminChanged(address previousAdmin, address newAdmin) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseAdminChanged(log types.Log) (*GatewayEVMEchidnaTestAdminChanged, error) { - event := new(GatewayEVMEchidnaTestAdminChanged) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "AdminChanged", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestBeaconUpgradedIterator is returned from FilterBeaconUpgraded and is used to iterate over the raw logs and unpacked data for BeaconUpgraded events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestBeaconUpgradedIterator struct { - Event *GatewayEVMEchidnaTestBeaconUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestBeaconUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestBeaconUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestBeaconUpgraded represents a BeaconUpgraded event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestBeaconUpgraded struct { - Beacon common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterBeaconUpgraded is a free log retrieval operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterBeaconUpgraded(opts *bind.FilterOpts, beacon []common.Address) (*GatewayEVMEchidnaTestBeaconUpgradedIterator, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestBeaconUpgradedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "BeaconUpgraded", logs: logs, sub: sub}, nil -} - -// WatchBeaconUpgraded is a free log subscription operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchBeaconUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestBeaconUpgraded, beacon []common.Address) (event.Subscription, error) { - - var beaconRule []interface{} - for _, beaconItem := range beacon { - beaconRule = append(beaconRule, beaconItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "BeaconUpgraded", beaconRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestBeaconUpgraded) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "BeaconUpgraded", 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 -} - -// ParseBeaconUpgraded is a log parse operation binding the contract event 0x1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e. -// -// Solidity: event BeaconUpgraded(address indexed beacon) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseBeaconUpgraded(log types.Log) (*GatewayEVMEchidnaTestBeaconUpgraded, error) { - event := new(GatewayEVMEchidnaTestBeaconUpgraded) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "BeaconUpgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestCallIterator struct { - Event *GatewayEVMEchidnaTestCall // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestCallIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestCallIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestCallIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestCall represents a Call event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestCall struct { - Sender common.Address - Receiver common.Address - Payload []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. -// -// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMEchidnaTestCallIterator, error) { - - var senderRule []interface{} - for _, senderItem := range sender { - senderRule = append(senderRule, senderItem) - } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Call", senderRule, receiverRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestCallIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Call", logs: logs, sub: sub}, nil -} - -// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. -// -// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { - - var senderRule []interface{} - for _, senderItem := range sender { - senderRule = append(senderRule, senderItem) - } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Call", senderRule, receiverRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestCall) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Call", 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 -} - -// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. -// -// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseCall(log types.Log) (*GatewayEVMEchidnaTestCall, error) { - event := new(GatewayEVMEchidnaTestCall) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Call", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestDepositIterator struct { - Event *GatewayEVMEchidnaTestDeposit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestDepositIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestDeposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestDeposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestDepositIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestDepositIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestDeposit represents a Deposit event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestDeposit struct { - Sender common.Address - Receiver common.Address - Amount *big.Int - Asset common.Address - Payload []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. -// -// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMEchidnaTestDepositIterator, error) { - - var senderRule []interface{} - for _, senderItem := range sender { - senderRule = append(senderRule, senderItem) - } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestDepositIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Deposit", logs: logs, sub: sub}, nil -} - -// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. -// -// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { - - var senderRule []interface{} - for _, senderItem := range sender { - senderRule = append(senderRule, senderItem) - } - var receiverRule []interface{} - for _, receiverItem := range receiver { - receiverRule = append(receiverRule, receiverItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestDeposit) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Deposit", 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 -} - -// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. -// -// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseDeposit(log types.Log) (*GatewayEVMEchidnaTestDeposit, error) { - event := new(GatewayEVMEchidnaTestDeposit) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Deposit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestExecutedIterator struct { - Event *GatewayEVMEchidnaTestExecuted // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestExecutedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestExecuted) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestExecuted) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestExecutedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestExecutedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestExecuted represents a Executed event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestExecuted struct { - Destination common.Address - Value *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMEchidnaTestExecutedIterator, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Executed", destinationRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestExecutedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Executed", logs: logs, sub: sub}, nil -} - -// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestExecuted, destination []common.Address) (event.Subscription, error) { - - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Executed", destinationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestExecuted) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Executed", 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 -} - -// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. -// -// Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseExecuted(log types.Log) (*GatewayEVMEchidnaTestExecuted, error) { - event := new(GatewayEVMEchidnaTestExecuted) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Executed", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestExecutedWithERC20Iterator struct { - Event *GatewayEVMEchidnaTestExecutedWithERC20 // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestExecutedWithERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestExecutedWithERC20) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestExecutedWithERC20Iterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestExecutedWithERC20 struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMEchidnaTestExecutedWithERC20Iterator, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestExecutedWithERC20Iterator{contract: _GatewayEVMEchidnaTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil -} - -// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { - - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) - } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestExecutedWithERC20) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "ExecutedWithERC20", 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 -} - -// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. -// -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMEchidnaTestExecutedWithERC20, error) { - event := new(GatewayEVMEchidnaTestExecutedWithERC20) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestInitializedIterator struct { - Event *GatewayEVMEchidnaTestInitialized // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestInitializedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestInitialized) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestInitializedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestInitializedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestInitialized represents a Initialized event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestInitialized struct { - Version uint8 - Raw types.Log // Blockchain specific contextual infos -} - -// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMEchidnaTestInitializedIterator, error) { - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestInitializedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Initialized", logs: logs, sub: sub}, nil -} - -// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestInitialized) (event.Subscription, error) { - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Initialized") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestInitialized) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Initialized", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. -// -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseInitialized(log types.Log) (*GatewayEVMEchidnaTestInitialized, error) { - event := new(GatewayEVMEchidnaTestInitialized) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Initialized", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestOwnershipTransferredIterator struct { - Event *GatewayEVMEchidnaTestOwnershipTransferred // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestOwnershipTransferred) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestOwnershipTransferredIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestOwnershipTransferred struct { - PreviousOwner common.Address - NewOwner common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMEchidnaTestOwnershipTransferredIterator, 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 := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestOwnershipTransferredIterator{contract: _GatewayEVMEchidnaTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil -} - -// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestOwnershipTransferred, 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 := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestOwnershipTransferred) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. -// -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMEchidnaTestOwnershipTransferred, error) { - event := new(GatewayEVMEchidnaTestOwnershipTransferred) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// GatewayEVMEchidnaTestUpgradedIterator is returned from FilterUpgraded and is used to iterate over the raw logs and unpacked data for Upgraded events raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestUpgradedIterator struct { - Event *GatewayEVMEchidnaTestUpgraded // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *GatewayEVMEchidnaTestUpgradedIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(GatewayEVMEchidnaTestUpgraded) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMEchidnaTestUpgradedIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *GatewayEVMEchidnaTestUpgradedIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// GatewayEVMEchidnaTestUpgraded represents a Upgraded event raised by the GatewayEVMEchidnaTest contract. -type GatewayEVMEchidnaTestUpgraded struct { - Implementation common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpgraded is a free log retrieval operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) FilterUpgraded(opts *bind.FilterOpts, implementation []common.Address) (*GatewayEVMEchidnaTestUpgradedIterator, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.FilterLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return &GatewayEVMEchidnaTestUpgradedIterator{contract: _GatewayEVMEchidnaTest.contract, event: "Upgraded", logs: logs, sub: sub}, nil -} - -// WatchUpgraded is a free log subscription operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) WatchUpgraded(opts *bind.WatchOpts, sink chan<- *GatewayEVMEchidnaTestUpgraded, implementation []common.Address) (event.Subscription, error) { - - var implementationRule []interface{} - for _, implementationItem := range implementation { - implementationRule = append(implementationRule, implementationItem) - } - - logs, sub, err := _GatewayEVMEchidnaTest.contract.WatchLogs(opts, "Upgraded", implementationRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(GatewayEVMEchidnaTestUpgraded) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Upgraded", log); err != nil { - return err - } - event.Raw = log - - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil -} - -// ParseUpgraded is a log parse operation binding the contract event 0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b. -// -// Solidity: event Upgraded(address indexed implementation) -func (_GatewayEVMEchidnaTest *GatewayEVMEchidnaTestFilterer) ParseUpgraded(log types.Log) (*GatewayEVMEchidnaTestUpgraded, error) { - event := new(GatewayEVMEchidnaTestUpgraded) - if err := _GatewayEVMEchidnaTest.contract.UnpackLog(event, "Upgraded", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol b/test/fuzz/ERC20CustodyNewEchidnaTest.sol similarity index 85% rename from contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol rename to test/fuzz/ERC20CustodyNewEchidnaTest.sol index 00e7ff9b..079334df 100644 --- a/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest.sol +++ b/test/fuzz/ERC20CustodyNewEchidnaTest.sol @@ -1,6 +1,6 @@ -import "./GatewayEVM.sol"; -import "./TestERC20.sol"; -import "./ERC20CustodyNew.sol"; +import "../../contracts/prototypes/evm/TestERC20.sol"; +import "../../contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "../../contracts/prototypes/evm/GatewayEVM.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -18,7 +18,6 @@ contract ERC20CustodyNewEchidnaTest is ERC20CustodyNew { testGateway.setCustody(address(this)); } - // Test withdrawAndCall with assertions function testWithdrawAndCall(address to, uint256 amount, bytes calldata data) public { // mint more than amount testERC20.mint(address(this), amount + 5); diff --git a/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol b/test/fuzz/GatewayEVMEchidnaTest.sol similarity index 82% rename from contracts/prototypes/evm/GatewayEVMEchidnaTest.sol rename to test/fuzz/GatewayEVMEchidnaTest.sol index 79f9f800..fda16cbe 100644 --- a/contracts/prototypes/evm/GatewayEVMEchidnaTest.sol +++ b/test/fuzz/GatewayEVMEchidnaTest.sol @@ -1,6 +1,6 @@ -import "./GatewayEVM.sol"; -import "./TestERC20.sol"; -import "./ERC20CustodyNew.sol"; +import "../../contracts/prototypes/evm/GatewayEVM.sol"; +import "../../contracts/prototypes/evm/TestERC20.sol"; +import "../../contracts/prototypes/evm/ERC20CustodyNew.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -16,7 +16,6 @@ contract GatewayEVMEchidnaTest is GatewayEVM { custody = address(new ERC20CustodyNew(address(this))); } - // Test executeWithERC20 with assertions function testExecuteWithERC20(address to, uint256 amount, bytes calldata data) public { testERC20.mint(address(this), amount); diff --git a/test/fuzz/readme.md b/test/fuzz/readme.md new file mode 100644 index 00000000..3c751a29 --- /dev/null +++ b/test/fuzz/readme.md @@ -0,0 +1,13 @@ +## Setup echidna + +``` +brew install echidna +solc-select use 0.8.7 +``` + +## Execute contract tests + +``` +echidna test/fuzz/ERC20CustodyNewEchidnaTest.sol --contract ERC20CustodyNewEchidnaTest --config echidna.yaml +echidna test/fuzz/GatewayEVMEchidnaTest.sol --contract GatewayEVMEchidnaTest --config echidna.yaml +``` \ No newline at end of file diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index cc5d7d54..939b9af8 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -4,9 +4,7 @@ import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; -export type { ERC20CustodyNewEchidnaTest } from "./ERC20CustodyNewEchidnaTest"; export type { GatewayEVM } from "./GatewayEVM"; -export type { GatewayEVMEchidnaTest } from "./GatewayEVMEchidnaTest"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index bba4f1fc..b7a35400 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -3,9 +3,7 @@ /* eslint-disable */ export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; -export { ERC20CustodyNewEchidnaTest__factory } from "./ERC20CustodyNewEchidnaTest__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; -export { GatewayEVMEchidnaTest__factory } from "./GatewayEVMEchidnaTest__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index d1871412..6f78440d 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -336,18 +336,10 @@ declare module "hardhat/types/runtime" { name: "ERC20CustodyNew", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "ERC20CustodyNewEchidnaTest", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "GatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "GatewayEVMEchidnaTest", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "GatewayEVMUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions @@ -862,21 +854,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "ERC20CustodyNewEchidnaTest", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "GatewayEVM", address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "GatewayEVMEchidnaTest", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "GatewayEVMUpgradeTest", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 94768cb5..f17533ca 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -158,12 +158,8 @@ export type { ZetaConnectorNonEth } from "./contracts/evm/ZetaConnector.non-eth. export { ZetaConnectorNonEth__factory } from "./factories/contracts/evm/ZetaConnector.non-eth.sol/ZetaConnectorNonEth__factory"; export type { ERC20CustodyNew } from "./contracts/prototypes/evm/ERC20CustodyNew"; export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNew__factory"; -export type { ERC20CustodyNewEchidnaTest } from "./contracts/prototypes/evm/ERC20CustodyNewEchidnaTest"; -export { ERC20CustodyNewEchidnaTest__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNewEchidnaTest__factory"; export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; -export type { GatewayEVMEchidnaTest } from "./contracts/prototypes/evm/GatewayEVMEchidnaTest"; -export { GatewayEVMEchidnaTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMEchidnaTest__factory"; export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; From 5524b59763a51cf0951c5e8c478b40fb6be016e5 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 8 Jul 2024 17:31:44 +0200 Subject: [PATCH 57/86] add hardhat foundry and simple test --- .gitignore | 5 +- .gitmodules | 3 ++ contracts/prototypes/evm/GatewayEVM.sol | 19 ++----- contracts/prototypes/evm/GatewayEVM.t.sol | 61 +++++++++++++++++++++++ contracts/prototypes/evm/interfaces.sol | 28 +++++++++-- foundry.toml | 7 +++ hardhat.config.ts | 1 + lib/forge-std | 1 + package.json | 1 + yarn.lock | 7 +++ 10 files changed, 112 insertions(+), 21 deletions(-) create mode 100644 .gitmodules create mode 100644 contracts/prototypes/evm/GatewayEVM.t.sol create mode 100644 foundry.toml create mode 160000 lib/forge-std diff --git a/.gitignore b/.gitignore index 39218d50..b857c4e9 100644 --- a/.gitignore +++ b/.gitignore @@ -32,4 +32,7 @@ scripts/slither-results/* abi -crytic-export \ No newline at end of file +crytic-export + +out +cache_forge \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 00000000..888d42dc --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "lib/forge-std"] + path = lib/forge-std + url = https://github.com/foundry-rs/forge-std diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 204784e7..78ca2a49 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -6,30 +6,17 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; +import "./interfaces.sol"; // The GatewayEVM contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances -contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGatewayEVMErrors, IGatewayEVMEvents { using SafeERC20 for IERC20; - error ExecutionFailed(); - error DepositFailed(); - error InsufficientETHAmount(); - error InsufficientERC20Amount(); - error ZeroAddress(); - error ApprovalFailed(); - error CustodyInitialized(); - address public custody; address public tssAddress; - event Executed(address indexed destination, uint256 value, bytes data); - event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); - event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); - event Call(address indexed sender, address indexed receiver, bytes payload); - - constructor() { - } + constructor() {} function initialize(address _tssAddress) public initializer { __Ownable_init(); diff --git a/contracts/prototypes/evm/GatewayEVM.t.sol b/contracts/prototypes/evm/GatewayEVM.t.sol new file mode 100644 index 00000000..dea62917 --- /dev/null +++ b/contracts/prototypes/evm/GatewayEVM.t.sol @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "forge-std/Test.sol"; +import "forge-std/Vm.sol"; + +import "contracts/prototypes/evm/GatewayEVM.sol"; +import "contracts/prototypes/evm/ReceiverEVM.sol"; +import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/TestERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "./interfaces.sol"; +import "forge-std/console.sol"; + +contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiverEVMEvents { + using SafeERC20 for IERC20; + + GatewayEVM gateway; + ReceiverEVM receiver; + ERC20CustodyNew custody; + TestERC20 token; + address owner; + address destination; + address tssAddress; + + function setUp() public { + owner = address(this); + destination = address(0x1234); + tssAddress = address(0x5678); + + token = new TestERC20("test", "TTK"); + gateway = new GatewayEVM(); + custody = new ERC20CustodyNew(address(gateway)); + + gateway.initialize(tssAddress); + gateway.setCustody(address(custody)); + + // Mint initial supply to the owner + token.mint(owner, 1000000); + + // Transfer some tokens to the custody contract + token.transfer(address(custody), 500000); + } + + function testForwardCallToReceivePayable() public { + string memory str = "Hello, Foundry!"; + uint256 num = 42; + bool flag = true; + uint256 value = 1 ether; + + bytes memory data = abi.encodeWithSignature("receivePayable(string,uint256,bool)", str, num, flag); + + vm.expectCall(address(receiver), value, data); + vm.expectEmit(true, true, true, true, address(gateway)); + emit Executed(address(receiver), value, data); + // TODO: can not check event emitted in Receiver? + + gateway.execute{value: value}(address(receiver), data); + } +} diff --git a/contracts/prototypes/evm/interfaces.sol b/contracts/prototypes/evm/interfaces.sol index 38d006c8..d170da79 100644 --- a/contracts/prototypes/evm/interfaces.sol +++ b/contracts/prototypes/evm/interfaces.sol @@ -1,6 +1,30 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; +interface IGatewayEVMEvents { + event Executed(address indexed destination, uint256 value, bytes data); + event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); + event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload); + event Call(address indexed sender, address indexed receiver, bytes payload); +} + +interface IGatewayEVMErrors { + error ExecutionFailed(); + error DepositFailed(); + error InsufficientETHAmount(); + error InsufficientERC20Amount(); + error ZeroAddress(); + error ApprovalFailed(); + error CustodyInitialized(); +} + +interface IReceiverEVMEvents { + event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag); + event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag); + event ReceivedERC20(address sender, uint256 amount, address token, address destination); + event ReceivedNoParams(address sender); +} + interface IGatewayEVM { function executeWithERC20( address token, @@ -10,8 +34,4 @@ interface IGatewayEVM { ) external returns (bytes memory); function execute(address destination, bytes calldata data) external payable returns (bytes memory); - - function sendERC20(bytes calldata recipient, address asset, uint256 amount) external; - - function send(bytes calldata recipient, uint256 amount) external payable; } \ No newline at end of file diff --git a/foundry.toml b/foundry.toml new file mode 100644 index 00000000..9f6482d0 --- /dev/null +++ b/foundry.toml @@ -0,0 +1,7 @@ +[profile.default] +src = 'contracts' +out = 'out' +libs = ['node_modules', 'lib'] +test = 'test' +cache_path = 'cache_forge' +no-match-contract = '.*EchidnaTest$' \ No newline at end of file diff --git a/hardhat.config.ts b/hardhat.config.ts index 8fdc1844..fbc22e99 100644 --- a/hardhat.config.ts +++ b/hardhat.config.ts @@ -9,6 +9,7 @@ import "hardhat-gas-reporter"; import "./tasks/addresses"; import "./tasks/localnet"; import "@openzeppelin/hardhat-upgrades"; +import "@nomicfoundation/hardhat-foundry"; import { getHardhatConfigNetworks } from "@zetachain/networks"; import * as dotenv from "dotenv"; diff --git a/lib/forge-std b/lib/forge-std new file mode 160000 index 00000000..07263d19 --- /dev/null +++ b/lib/forge-std @@ -0,0 +1 @@ +Subproject commit 07263d193d621c4b2b0ce8b4d54af58f6957d97d diff --git a/package.json b/package.json index 5e987a5f..8bcbe979 100644 --- a/package.json +++ b/package.json @@ -5,6 +5,7 @@ "@ethersproject/abi": "^5.4.7", "@ethersproject/providers": "^5.4.7", "@nomicfoundation/hardhat-chai-matchers": "^1.0.6", + "@nomicfoundation/hardhat-foundry": "^1.1.2", "@nomicfoundation/hardhat-network-helpers": "^1.0.0", "@nomicfoundation/hardhat-toolbox": "^2.0.0", "@nomicfoundation/hardhat-verify": "2.0.3", diff --git a/yarn.lock b/yarn.lock index 9202ef21..6dc8d789 100644 --- a/yarn.lock +++ b/yarn.lock @@ -1509,6 +1509,13 @@ deep-eql "^4.0.1" ordinal "^1.0.3" +"@nomicfoundation/hardhat-foundry@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@nomicfoundation/hardhat-foundry/-/hardhat-foundry-1.1.2.tgz#4f5aaa1803b8f5d974dcbc361beb72d49c815562" + integrity sha512-f5Vhj3m2qvKGpr6NAINYwNgILDsai8dVCsFb1rAVLkJxOmD2pAtfCmOH5SBVr9yUI5B1z9rbTwPBJVrqnb+PXQ== + dependencies: + chalk "^2.4.2" + "@nomicfoundation/hardhat-network-helpers@^1.0.0": version "1.0.8" resolved "https://registry.npmjs.org/@nomicfoundation/hardhat-network-helpers/-/hardhat-network-helpers-1.0.8.tgz" From 4f1b2c2b89228809468fa32f74de1893b05d7394 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 8 Jul 2024 17:33:14 +0200 Subject: [PATCH 58/86] bump hardhat --- package.json | 2 +- yarn.lock | 599 +++++++++++++-------------------------------------- 2 files changed, 149 insertions(+), 452 deletions(-) diff --git a/package.json b/package.json index 8bcbe979..ffcf9bc8 100644 --- a/package.json +++ b/package.json @@ -47,7 +47,7 @@ "ethereum-waffle": "^4.0.9", "ethereumjs-utils": "^5.2.5", "ethers": "5.6.8", - "hardhat": "^2.13.1", + "hardhat": "^2.17.2", "hardhat-abi-exporter": "^2.10.1", "hardhat-gas-reporter": "^1.0.9", "inquirer": "^8.2.4", diff --git a/yarn.lock b/yarn.lock index 6dc8d789..f8e6a1a5 100644 --- a/yarn.lock +++ b/yarn.lock @@ -70,42 +70,6 @@ dependencies: regenerator-runtime "^0.14.0" -"@chainsafe/as-sha256@^0.3.1": - version "0.3.1" - resolved "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-0.3.1.tgz" - integrity sha512-hldFFYuf49ed7DAakWVXSJODuq3pzJEguD8tQ7h+sGkM18vja+OFoJI9krnGmgzyuZC2ETX0NOIcCTy31v2Mtg== - -"@chainsafe/persistent-merkle-tree@^0.4.2": - version "0.4.2" - resolved "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.4.2.tgz" - integrity sha512-lLO3ihKPngXLTus/L7WHKaw9PnNJWizlOF1H9NNzHP6Xvh82vzg9F2bzkXhYIFshMZ2gTCEz8tq6STe7r5NDfQ== - dependencies: - "@chainsafe/as-sha256" "^0.3.1" - -"@chainsafe/persistent-merkle-tree@^0.5.0": - version "0.5.0" - resolved "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.5.0.tgz" - integrity sha512-l0V1b5clxA3iwQLXP40zYjyZYospQLZXzBVIhhr9kDg/1qHZfzzHw0jj4VPBijfYCArZDlPkRi1wZaV2POKeuw== - dependencies: - "@chainsafe/as-sha256" "^0.3.1" - -"@chainsafe/ssz@^0.10.0": - version "0.10.2" - resolved "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.10.2.tgz" - integrity sha512-/NL3Lh8K+0q7A3LsiFq09YXS9fPE+ead2rr7vM2QK8PLzrNsw3uqrif9bpRX5UxgeRjM+vYi+boCM3+GM4ovXg== - dependencies: - "@chainsafe/as-sha256" "^0.3.1" - "@chainsafe/persistent-merkle-tree" "^0.5.0" - -"@chainsafe/ssz@^0.9.2": - version "0.9.4" - resolved "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.9.4.tgz" - integrity sha512-77Qtg2N1ayqs4Bg/wvnWfg5Bta7iy7IRh8XqXh7oNMeP2HBbBwx8m6yTpA8p0EHItWPEBkgZd5S5/LSlp3GXuQ== - dependencies: - "@chainsafe/as-sha256" "^0.3.1" - "@chainsafe/persistent-merkle-tree" "^0.4.2" - case "^1.6.3" - "@changesets/apply-release-plan@^6.1.3": version "6.1.3" resolved "https://registry.npmjs.org/@changesets/apply-release-plan/-/apply-release-plan-6.1.3.tgz" @@ -501,7 +465,7 @@ "@ethersproject/properties" "^5.6.0" "@ethersproject/strings" "^5.6.1" -"@ethersproject/abi@5.7.0", "@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.0.9", "@ethersproject/abi@^5.1.2", "@ethersproject/abi@^5.4.7", "@ethersproject/abi@^5.5.0", "@ethersproject/abi@^5.6.3", "@ethersproject/abi@^5.7.0": +"@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.0.9", "@ethersproject/abi@^5.1.2", "@ethersproject/abi@^5.4.7", "@ethersproject/abi@^5.5.0", "@ethersproject/abi@^5.6.3": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz" integrity sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA== @@ -529,7 +493,7 @@ "@ethersproject/transactions" "^5.6.2" "@ethersproject/web" "^5.6.1" -"@ethersproject/abstract-provider@5.7.0", "@ethersproject/abstract-provider@^5.6.1", "@ethersproject/abstract-provider@^5.7.0": +"@ethersproject/abstract-provider@^5.6.1", "@ethersproject/abstract-provider@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz" integrity sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw== @@ -553,7 +517,7 @@ "@ethersproject/logger" "^5.6.0" "@ethersproject/properties" "^5.6.0" -"@ethersproject/abstract-signer@5.7.0", "@ethersproject/abstract-signer@^5.6.2", "@ethersproject/abstract-signer@^5.7.0": +"@ethersproject/abstract-signer@^5.6.2", "@ethersproject/abstract-signer@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz" integrity sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ== @@ -575,7 +539,7 @@ "@ethersproject/logger" "^5.6.0" "@ethersproject/rlp" "^5.6.1" -"@ethersproject/address@5.7.0", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.6.1", "@ethersproject/address@^5.7.0": +"@ethersproject/address@^5.0.2", "@ethersproject/address@^5.6.1", "@ethersproject/address@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz" integrity sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA== @@ -593,7 +557,7 @@ dependencies: "@ethersproject/bytes" "^5.6.1" -"@ethersproject/base64@5.7.0", "@ethersproject/base64@^5.6.1", "@ethersproject/base64@^5.7.0": +"@ethersproject/base64@^5.6.1", "@ethersproject/base64@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz" integrity sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ== @@ -608,7 +572,7 @@ "@ethersproject/bytes" "^5.6.1" "@ethersproject/properties" "^5.6.0" -"@ethersproject/basex@5.7.0", "@ethersproject/basex@^5.6.1", "@ethersproject/basex@^5.7.0": +"@ethersproject/basex@^5.6.1", "@ethersproject/basex@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz" integrity sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw== @@ -625,7 +589,7 @@ "@ethersproject/logger" "^5.6.0" bn.js "^5.2.1" -"@ethersproject/bignumber@5.7.0", "@ethersproject/bignumber@^5.6.2", "@ethersproject/bignumber@^5.7.0": +"@ethersproject/bignumber@^5.6.2", "@ethersproject/bignumber@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz" integrity sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw== @@ -641,7 +605,7 @@ dependencies: "@ethersproject/logger" "^5.6.0" -"@ethersproject/bytes@5.7.0", "@ethersproject/bytes@^5.6.1", "@ethersproject/bytes@^5.7.0": +"@ethersproject/bytes@^5.6.1", "@ethersproject/bytes@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz" integrity sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A== @@ -655,7 +619,7 @@ dependencies: "@ethersproject/bignumber" "^5.6.2" -"@ethersproject/constants@5.7.0", "@ethersproject/constants@^5.6.1", "@ethersproject/constants@^5.7.0": +"@ethersproject/constants@^5.6.1", "@ethersproject/constants@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz" integrity sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA== @@ -678,22 +642,6 @@ "@ethersproject/properties" "^5.6.0" "@ethersproject/transactions" "^5.6.2" -"@ethersproject/contracts@5.7.0": - version "5.7.0" - resolved "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz" - integrity sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg== - dependencies: - "@ethersproject/abi" "^5.7.0" - "@ethersproject/abstract-provider" "^5.7.0" - "@ethersproject/abstract-signer" "^5.7.0" - "@ethersproject/address" "^5.7.0" - "@ethersproject/bignumber" "^5.7.0" - "@ethersproject/bytes" "^5.7.0" - "@ethersproject/constants" "^5.7.0" - "@ethersproject/logger" "^5.7.0" - "@ethersproject/properties" "^5.7.0" - "@ethersproject/transactions" "^5.7.0" - "@ethersproject/hash@5.6.1": version "5.6.1" resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.6.1.tgz" @@ -708,7 +656,7 @@ "@ethersproject/properties" "^5.6.0" "@ethersproject/strings" "^5.6.1" -"@ethersproject/hash@5.7.0", "@ethersproject/hash@^5.6.1", "@ethersproject/hash@^5.7.0": +"@ethersproject/hash@^5.6.1", "@ethersproject/hash@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz" integrity sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g== @@ -741,7 +689,7 @@ "@ethersproject/transactions" "^5.6.2" "@ethersproject/wordlists" "^5.6.1" -"@ethersproject/hdnode@5.7.0", "@ethersproject/hdnode@^5.6.2", "@ethersproject/hdnode@^5.7.0": +"@ethersproject/hdnode@^5.6.2", "@ethersproject/hdnode@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz" integrity sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg== @@ -778,7 +726,7 @@ aes-js "3.0.0" scrypt-js "3.0.1" -"@ethersproject/json-wallets@5.7.0", "@ethersproject/json-wallets@^5.6.1", "@ethersproject/json-wallets@^5.7.0": +"@ethersproject/json-wallets@^5.6.1": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz" integrity sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g== @@ -805,7 +753,7 @@ "@ethersproject/bytes" "^5.6.1" js-sha3 "0.8.0" -"@ethersproject/keccak256@5.7.0", "@ethersproject/keccak256@^5.6.1", "@ethersproject/keccak256@^5.7.0": +"@ethersproject/keccak256@^5.6.1", "@ethersproject/keccak256@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz" integrity sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg== @@ -818,7 +766,7 @@ resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.6.0.tgz" integrity sha512-BiBWllUROH9w+P21RzoxJKzqoqpkyM1pRnEKG69bulE9TSQD8SAIvTQqIMZmmCO8pUNkgLP1wndX1gKghSpBmg== -"@ethersproject/logger@5.7.0", "@ethersproject/logger@^5.6.0", "@ethersproject/logger@^5.7.0": +"@ethersproject/logger@^5.6.0", "@ethersproject/logger@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz" integrity sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig== @@ -830,7 +778,7 @@ dependencies: "@ethersproject/logger" "^5.6.0" -"@ethersproject/networks@5.7.1", "@ethersproject/networks@^5.6.3", "@ethersproject/networks@^5.7.0": +"@ethersproject/networks@^5.6.3", "@ethersproject/networks@^5.7.0": version "5.7.1" resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz" integrity sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ== @@ -845,7 +793,7 @@ "@ethersproject/bytes" "^5.6.1" "@ethersproject/sha2" "^5.6.1" -"@ethersproject/pbkdf2@5.7.0", "@ethersproject/pbkdf2@^5.6.1", "@ethersproject/pbkdf2@^5.7.0": +"@ethersproject/pbkdf2@^5.6.1", "@ethersproject/pbkdf2@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz" integrity sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw== @@ -860,7 +808,7 @@ dependencies: "@ethersproject/logger" "^5.6.0" -"@ethersproject/properties@5.7.0", "@ethersproject/properties@^5.6.0", "@ethersproject/properties@^5.7.0": +"@ethersproject/properties@^5.6.0", "@ethersproject/properties@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz" integrity sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw== @@ -893,7 +841,7 @@ bech32 "1.1.4" ws "7.4.6" -"@ethersproject/providers@5.7.2", "@ethersproject/providers@^5.4.7", "@ethersproject/providers@^5.7.1", "@ethersproject/providers@^5.7.2": +"@ethersproject/providers@^5.4.7": version "5.7.2" resolved "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz" integrity sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg== @@ -927,7 +875,7 @@ "@ethersproject/bytes" "^5.6.1" "@ethersproject/logger" "^5.6.0" -"@ethersproject/random@5.7.0", "@ethersproject/random@^5.6.1", "@ethersproject/random@^5.7.0": +"@ethersproject/random@^5.6.1", "@ethersproject/random@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz" integrity sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ== @@ -943,7 +891,7 @@ "@ethersproject/bytes" "^5.6.1" "@ethersproject/logger" "^5.6.0" -"@ethersproject/rlp@5.7.0", "@ethersproject/rlp@^5.6.1", "@ethersproject/rlp@^5.7.0": +"@ethersproject/rlp@^5.6.1", "@ethersproject/rlp@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz" integrity sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w== @@ -960,7 +908,7 @@ "@ethersproject/logger" "^5.6.0" hash.js "1.1.7" -"@ethersproject/sha2@5.7.0", "@ethersproject/sha2@^5.6.1", "@ethersproject/sha2@^5.7.0": +"@ethersproject/sha2@^5.6.1", "@ethersproject/sha2@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz" integrity sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw== @@ -981,7 +929,7 @@ elliptic "6.5.4" hash.js "1.1.7" -"@ethersproject/signing-key@5.7.0", "@ethersproject/signing-key@^5.6.2", "@ethersproject/signing-key@^5.7.0": +"@ethersproject/signing-key@^5.6.2", "@ethersproject/signing-key@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz" integrity sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q== @@ -1005,18 +953,6 @@ "@ethersproject/sha2" "^5.6.1" "@ethersproject/strings" "^5.6.1" -"@ethersproject/solidity@5.7.0": - version "5.7.0" - resolved "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz" - integrity sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA== - dependencies: - "@ethersproject/bignumber" "^5.7.0" - "@ethersproject/bytes" "^5.7.0" - "@ethersproject/keccak256" "^5.7.0" - "@ethersproject/logger" "^5.7.0" - "@ethersproject/sha2" "^5.7.0" - "@ethersproject/strings" "^5.7.0" - "@ethersproject/strings@5.6.1": version "5.6.1" resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.6.1.tgz" @@ -1026,7 +962,7 @@ "@ethersproject/constants" "^5.6.1" "@ethersproject/logger" "^5.6.0" -"@ethersproject/strings@5.7.0", "@ethersproject/strings@^5.6.1", "@ethersproject/strings@^5.7.0": +"@ethersproject/strings@^5.6.1", "@ethersproject/strings@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz" integrity sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg== @@ -1050,7 +986,7 @@ "@ethersproject/rlp" "^5.6.1" "@ethersproject/signing-key" "^5.6.2" -"@ethersproject/transactions@5.7.0", "@ethersproject/transactions@^5.6.2", "@ethersproject/transactions@^5.7.0": +"@ethersproject/transactions@^5.6.2", "@ethersproject/transactions@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz" integrity sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ== @@ -1074,15 +1010,6 @@ "@ethersproject/constants" "^5.6.1" "@ethersproject/logger" "^5.6.0" -"@ethersproject/units@5.7.0": - version "5.7.0" - resolved "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz" - integrity sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg== - dependencies: - "@ethersproject/bignumber" "^5.7.0" - "@ethersproject/constants" "^5.7.0" - "@ethersproject/logger" "^5.7.0" - "@ethersproject/wallet@5.6.2": version "5.6.2" resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.6.2.tgz" @@ -1104,27 +1031,6 @@ "@ethersproject/transactions" "^5.6.2" "@ethersproject/wordlists" "^5.6.1" -"@ethersproject/wallet@5.7.0": - version "5.7.0" - resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz" - integrity sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA== - dependencies: - "@ethersproject/abstract-provider" "^5.7.0" - "@ethersproject/abstract-signer" "^5.7.0" - "@ethersproject/address" "^5.7.0" - "@ethersproject/bignumber" "^5.7.0" - "@ethersproject/bytes" "^5.7.0" - "@ethersproject/hash" "^5.7.0" - "@ethersproject/hdnode" "^5.7.0" - "@ethersproject/json-wallets" "^5.7.0" - "@ethersproject/keccak256" "^5.7.0" - "@ethersproject/logger" "^5.7.0" - "@ethersproject/properties" "^5.7.0" - "@ethersproject/random" "^5.7.0" - "@ethersproject/signing-key" "^5.7.0" - "@ethersproject/transactions" "^5.7.0" - "@ethersproject/wordlists" "^5.7.0" - "@ethersproject/web@5.6.1": version "5.6.1" resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.6.1.tgz" @@ -1136,7 +1042,7 @@ "@ethersproject/properties" "^5.6.0" "@ethersproject/strings" "^5.6.1" -"@ethersproject/web@5.7.1", "@ethersproject/web@^5.6.1", "@ethersproject/web@^5.7.0": +"@ethersproject/web@^5.6.1", "@ethersproject/web@^5.7.0": version "5.7.1" resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz" integrity sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w== @@ -1158,7 +1064,7 @@ "@ethersproject/properties" "^5.6.0" "@ethersproject/strings" "^5.6.1" -"@ethersproject/wordlists@5.7.0", "@ethersproject/wordlists@^5.6.1", "@ethersproject/wordlists@^5.7.0": +"@ethersproject/wordlists@^5.6.1", "@ethersproject/wordlists@^5.7.0": version "5.7.0" resolved "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz" integrity sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA== @@ -1364,139 +1270,83 @@ "@nodelib/fs.scandir" "2.1.5" fastq "^1.6.0" -"@nomicfoundation/ethereumjs-block@5.0.0": - version "5.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-5.0.0.tgz" - integrity sha512-DfhVbqM5DjriguuSv6r3TgOpyXC76oX8D/VEODsSwJQ1bZGqu4xLLfYPPTacpCAYOnewzJsZli+Ao9TBTAo2uw== - dependencies: - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-trie" "6.0.0" - "@nomicfoundation/ethereumjs-tx" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - ethereum-cryptography "0.1.3" - ethers "^5.7.1" +"@nomicfoundation/edr-darwin-arm64@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-darwin-arm64/-/edr-darwin-arm64-0.4.1.tgz#210e6b5eaff9278814e8f19800182d1071554855" + integrity sha512-XuiUUnWAVNw7JYv7nRqDWfpBm21HOxCRBQ8lQnRnmiets9Ss2X5Ul9mvBheIPh/D0wBzwJ8TRtsSrorpwE79cA== -"@nomicfoundation/ethereumjs-blockchain@7.0.0": - version "7.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-7.0.0.tgz" - integrity sha512-cVRCrXZminZr0Mbx2hm0/109GZLn1v5bf0/k+SIbGn50yZm6YCdQt9CgGT0Gk56N2vy8NhXD4apo167m4LWk6Q== - dependencies: - "@nomicfoundation/ethereumjs-block" "5.0.0" - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-ethash" "3.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-trie" "6.0.0" - "@nomicfoundation/ethereumjs-tx" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - abstract-level "^1.0.3" - debug "^4.3.3" - ethereum-cryptography "0.1.3" - level "^8.0.0" - lru-cache "^5.1.1" - memory-level "^1.0.0" +"@nomicfoundation/edr-darwin-x64@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-darwin-x64/-/edr-darwin-x64-0.4.1.tgz#81e660de77d1d73317c9a5140349d1197cddef9a" + integrity sha512-N1MfJqEX5ixaXlyyrHnaYxzwIT27Nc/jUgLI7ts4/9kRvPTvyZRYmXS1ciKhmUFr/WvFckTCix2RJbZoGGtX7g== -"@nomicfoundation/ethereumjs-common@4.0.0": - version "4.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-4.0.0.tgz" - integrity sha512-UPpm5FAGAf2B6hQ8aVgO44Rdo0k73oMMCViqNJcKMlk1s9l3rxwuPTp1l20NiGvNO2Pzqk3chFL+BzmLL2g4wQ== - dependencies: - "@nomicfoundation/ethereumjs-util" "9.0.0" - crc-32 "^1.2.0" +"@nomicfoundation/edr-linux-arm64-gnu@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-linux-arm64-gnu/-/edr-linux-arm64-gnu-0.4.1.tgz#6e1ce12080a35505c7f3eaf772f4e171db8b7f9a" + integrity sha512-bSPOfmcFjJwDgWOV5kgZHeqg2OWu1cINrHSGjig0aVHehjcoX4Sgayrj6fyAxcOV5NQKA6WcyTFll6NrCxzWRA== -"@nomicfoundation/ethereumjs-ethash@3.0.0": - version "3.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-3.0.0.tgz" - integrity sha512-6zNv5Y3vNIsxjrsbKjMInVpo8cmR0c7yjZbBpy7NYuIMtm0JKhQoXsiFN56t/1sfn9V3v0wgrkAixo5v6bahpA== - dependencies: - "@nomicfoundation/ethereumjs-block" "5.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - abstract-level "^1.0.3" - bigint-crypto-utils "^3.0.23" - ethereum-cryptography "0.1.3" +"@nomicfoundation/edr-linux-arm64-musl@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-linux-arm64-musl/-/edr-linux-arm64-musl-0.4.1.tgz#a467a6c8631053d10a8641f67618b9bdf057c636" + integrity sha512-F/+DgOdeBFQDrk+SX4aFffJFBgJfd75ZtE2mjcWNAh/qWiS7NfUxdQX/5OvNo/H6EY4a+3bZH6Bgzqg4mEWvMw== -"@nomicfoundation/ethereumjs-evm@2.0.0": - version "2.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-2.0.0.tgz" - integrity sha512-D+tr3M9sictopr3E20OVgme7YF/d0fU566WKh+ofXwmxapz/Dd8RSLSaVeKgfCI2BkzVA+XqXY08NNCV8w8fWA== - dependencies: - "@ethersproject/providers" "^5.7.1" - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-tx" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - debug "^4.3.3" - ethereum-cryptography "0.1.3" - mcl-wasm "^0.7.1" - rustbn.js "~0.2.0" +"@nomicfoundation/edr-linux-x64-gnu@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-linux-x64-gnu/-/edr-linux-x64-gnu-0.4.1.tgz#63753d05767b4bc0d4f9f9be8399928c790c931e" + integrity sha512-POHhTWczIXCPhzKtY0Vt/l+VCqqCx5gNR5ErwSrNnLz/arfQobZFAU+nc61BX3Jch82TW8b3AbfGI73Kh7gO0w== -"@nomicfoundation/ethereumjs-rlp@5.0.0": - version "5.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-5.0.0.tgz" - integrity sha512-U1A0y330PtGb8Wft4yPVv0myWYJTesi89ItGoB0ICdqz7793KmUhpfQb2vJUXBi98wSdnxkIABO/GmsQvGKVDw== +"@nomicfoundation/edr-linux-x64-musl@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-linux-x64-musl/-/edr-linux-x64-musl-0.4.1.tgz#44d128b9a09e3f61b08617213a58cd84dd15c418" + integrity sha512-uu8oNp4Ozg3H1x1We0FF+rwXfFiAvsOm5GQ+OBx9YYOXnfDPWqguQfGIkhrti9GD0iYhfQ/WOG5wvp0IzzgGSg== -"@nomicfoundation/ethereumjs-statemanager@2.0.0": - version "2.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-2.0.0.tgz" - integrity sha512-tgXtsx8yIDlxWMN+ThqPtGK0ITAuITrDy+GYIgGrnT6ZtelvXWM7SUYR0Mcv578lmGCoIwyHFtSBqOkOBYHLjw== - dependencies: - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - debug "^4.3.3" - ethereum-cryptography "0.1.3" - ethers "^5.7.1" - js-sdsl "^4.1.4" +"@nomicfoundation/edr-win32-x64-msvc@0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr-win32-x64-msvc/-/edr-win32-x64-msvc-0.4.1.tgz#1667b725337ca6f27ec58c63337b6a62a0d7ed09" + integrity sha512-PaZHFw455z89ZiKYNTnKu+/TiVZVRI+mRJsbRTe2N0VlYfUBS1o2gdXBM12oP1t198HR7xQwEPPAslTFxGBqHA== -"@nomicfoundation/ethereumjs-trie@6.0.0": - version "6.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-6.0.0.tgz" - integrity sha512-YqPWiNxrZvL+Ef7KHqgru1IlaIGXhu78wd2fxNFOvi/NAQBF845dVfTKKXs1L9x0QBRRQRephgxHCKMuISGppw== +"@nomicfoundation/edr@^0.4.1": + version "0.4.1" + resolved "https://registry.yarnpkg.com/@nomicfoundation/edr/-/edr-0.4.1.tgz#7d698454d228ffc5399f1c58799104b53e1b60ae" + integrity sha512-NgrMo2rI9r28uidumvd+K2/AJLdxtXsUlJr3hj/pM6S1FCd/HiWaLeLa/cjCVPcE2u1rYAa3W6UFxLCB7S5Dhw== + dependencies: + "@nomicfoundation/edr-darwin-arm64" "0.4.1" + "@nomicfoundation/edr-darwin-x64" "0.4.1" + "@nomicfoundation/edr-linux-arm64-gnu" "0.4.1" + "@nomicfoundation/edr-linux-arm64-musl" "0.4.1" + "@nomicfoundation/edr-linux-x64-gnu" "0.4.1" + "@nomicfoundation/edr-linux-x64-musl" "0.4.1" + "@nomicfoundation/edr-win32-x64-msvc" "0.4.1" + +"@nomicfoundation/ethereumjs-common@4.0.4": + version "4.0.4" + resolved "https://registry.yarnpkg.com/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-4.0.4.tgz#9901f513af2d4802da87c66d6f255b510bef5acb" + integrity sha512-9Rgb658lcWsjiicr5GzNCjI1llow/7r0k50dLL95OJ+6iZJcVbi15r3Y0xh2cIO+zgX0WIHcbzIu6FeQf9KPrg== dependencies: - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - "@types/readable-stream" "^2.3.13" - ethereum-cryptography "0.1.3" - readable-stream "^3.6.0" + "@nomicfoundation/ethereumjs-util" "9.0.4" -"@nomicfoundation/ethereumjs-tx@5.0.0": - version "5.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-5.0.0.tgz" - integrity sha512-LTyxI+zBJ+HuEBblUGbxvfKl1hg1uJlz2XhnszNagiBWQSgLb1vQCa1QaXV5Q8cUDYkr/Xe4NXWiUGEvH4e6lA== - dependencies: - "@chainsafe/ssz" "^0.9.2" - "@ethersproject/providers" "^5.7.2" - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - ethereum-cryptography "0.1.3" +"@nomicfoundation/ethereumjs-rlp@5.0.4": + version "5.0.4" + resolved "https://registry.yarnpkg.com/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-5.0.4.tgz#66c95256fc3c909f6fb18f6a586475fc9762fa30" + integrity sha512-8H1S3s8F6QueOc/X92SdrA4RDenpiAEqMg5vJH99kcQaCy/a3Q6fgseo75mgWlbanGJXSlAPtnCeG9jvfTYXlw== -"@nomicfoundation/ethereumjs-util@9.0.0": - version "9.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-9.0.0.tgz" - integrity sha512-9EG98CsEC9BnI7AY27F4QXZ8Vf0re8R9XoxQ0//KWF+B7quu6GQvgTq1RlNUjGh/XNCCJNf8E3LOY9ULR85wFQ== +"@nomicfoundation/ethereumjs-tx@5.0.4": + version "5.0.4" + resolved "https://registry.yarnpkg.com/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-5.0.4.tgz#b0ceb58c98cc34367d40a30d255d6315b2f456da" + integrity sha512-Xjv8wAKJGMrP1f0n2PeyfFCCojHd7iS3s/Ab7qzF1S64kxZ8Z22LCMynArYsVqiFx6rzYy548HNVEyI+AYN/kw== dependencies: - "@chainsafe/ssz" "^0.10.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" + "@nomicfoundation/ethereumjs-common" "4.0.4" + "@nomicfoundation/ethereumjs-rlp" "5.0.4" + "@nomicfoundation/ethereumjs-util" "9.0.4" ethereum-cryptography "0.1.3" -"@nomicfoundation/ethereumjs-vm@7.0.0": - version "7.0.0" - resolved "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-7.0.0.tgz" - integrity sha512-eHkEoe/4r4+g+fZyIIlQjBHEjCPFs8CHiIEEMvMfvFrV4hyHnuTg4LH7l92ok7TGZqpWxgMG2JOEUFkNsXrKuQ== - dependencies: - "@nomicfoundation/ethereumjs-block" "5.0.0" - "@nomicfoundation/ethereumjs-blockchain" "7.0.0" - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-evm" "2.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-statemanager" "2.0.0" - "@nomicfoundation/ethereumjs-trie" "6.0.0" - "@nomicfoundation/ethereumjs-tx" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - debug "^4.3.3" +"@nomicfoundation/ethereumjs-util@9.0.4": + version "9.0.4" + resolved "https://registry.yarnpkg.com/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-9.0.4.tgz#84c5274e82018b154244c877b76bc049a4ed7b38" + integrity sha512-sLOzjnSrlx9Bb9EFNtHzK/FJFsfg2re6bsGqinFinH1gCqVfz9YYlXiMWwDM4C/L4ywuHFCYwfKTVr/QHQcU0Q== + dependencies: + "@nomicfoundation/ethereumjs-rlp" "5.0.4" ethereum-cryptography "0.1.3" - mcl-wasm "^0.7.1" - rustbn.js "~0.2.0" "@nomicfoundation/hardhat-chai-matchers@^1.0.6": version "1.0.6" @@ -2138,14 +1988,6 @@ resolved "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz" integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw== -"@types/readable-stream@^2.3.13": - version "2.3.15" - resolved "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-2.3.15.tgz" - integrity sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ== - dependencies: - "@types/node" "*" - safe-buffer "~5.1.1" - "@types/secp256k1@^4.0.1": version "4.0.3" resolved "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz" @@ -2327,26 +2169,6 @@ abbrev@1.0.x: resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz" integrity sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q== -abort-controller@^3.0.0: - version "3.0.0" - resolved "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz" - integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== - dependencies: - event-target-shim "^5.0.0" - -abstract-level@^1.0.0, abstract-level@^1.0.2, abstract-level@^1.0.3: - version "1.0.3" - resolved "https://registry.npmjs.org/abstract-level/-/abstract-level-1.0.3.tgz" - integrity sha512-t6jv+xHy+VYwc4xqZMn2Pa9DjcdzvzZmQGRjTFc8spIbRGHgBrEKbPq+rYXc7CCo0lxgYvSgKVg9qZAhpVQSjA== - dependencies: - buffer "^6.0.3" - catering "^2.1.0" - is-buffer "^2.0.5" - level-supports "^4.0.0" - level-transcoder "^1.0.1" - module-error "^1.0.1" - queue-microtask "^1.2.3" - abstract-leveldown@^6.2.1: version "6.3.0" resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-6.3.0.tgz" @@ -2470,6 +2292,13 @@ amdefine@>=0.0.4: resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz" integrity sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg== +ansi-align@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/ansi-align/-/ansi-align-3.0.1.tgz#0cdf12e111ace773a86e9a1fad1225c43cb19a59" + integrity sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w== + dependencies: + string-width "^4.1.0" + ansi-colors@3.2.3: version "3.2.3" resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz" @@ -2897,11 +2726,6 @@ better-path-resolve@1.0.0: dependencies: is-windows "^1.0.0" -bigint-crypto-utils@^3.0.23: - version "3.2.2" - resolved "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.2.2.tgz" - integrity sha512-U1RbE3aX9ayCUVcIPHuPDPKcK3SFOXf93J1UK/iHlJuQB7bhagPIX06/CLpLEsDThJ7KA4Dhrnzynl+d2weTiw== - bignumber.js@^9.0.0: version "9.1.1" resolved "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.1.1.tgz" @@ -2970,6 +2794,20 @@ bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1: resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz" integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ== +boxen@^5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/boxen/-/boxen-5.1.2.tgz#788cb686fc83c1f486dfa8a40c68fc2b831d2b50" + integrity sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ== + dependencies: + ansi-align "^3.0.0" + camelcase "^6.2.0" + chalk "^4.1.0" + cli-boxes "^2.2.1" + string-width "^4.2.2" + type-fest "^0.20.2" + widest-line "^3.1.0" + wrap-ansi "^7.0.0" + brace-expansion@^1.1.7: version "1.1.11" resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz" @@ -3029,16 +2867,6 @@ brorand@^1.0.1, brorand@^1.1.0: resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz" integrity sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w== -browser-level@^1.0.1: - version "1.0.1" - resolved "https://registry.npmjs.org/browser-level/-/browser-level-1.0.1.tgz" - integrity sha512-XECYKJ+Dbzw0lbydyQuJzwNXtOpbMSq737qxJN11sIRTErOMShvDpbzTlgju7orJKvx4epULolZAuJGLzCmWRQ== - dependencies: - abstract-level "^1.0.2" - catering "^2.1.1" - module-error "^1.0.2" - run-parallel-limit "^1.1.0" - browser-stdout@1.3.1: version "1.3.1" resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz" @@ -3214,22 +3042,17 @@ camelcase@^5.0.0, camelcase@^5.3.1: resolved "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz" integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== -camelcase@^6.0.0, camelcase@^6.3.0: +camelcase@^6.0.0, camelcase@^6.2.0, camelcase@^6.3.0: version "6.3.0" resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz" integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== -case@^1.6.3: - version "1.6.3" - resolved "https://registry.npmjs.org/case/-/case-1.6.3.tgz" - integrity sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ== - caseless@^0.12.0, caseless@~0.12.0: version "0.12.0" resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz" integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw== -catering@^2.0.0, catering@^2.1.0, catering@^2.1.1: +catering@^2.0.0, catering@^2.1.0: version "2.1.1" resolved "https://registry.npmjs.org/catering/-/catering-2.1.1.tgz" integrity sha512-K7Qy8O9p76sL3/3m7/zLKbRkyOlSZAgzEaLhyj2mXS8PsCud2Eo4hAb8aLtZqHh0QGqLcb9dlJSu6lHRVENm1w== @@ -3374,17 +3197,6 @@ class-utils@^0.3.5: isobject "^3.0.0" static-extend "^0.1.1" -classic-level@^1.2.0: - version "1.3.0" - resolved "https://registry.npmjs.org/classic-level/-/classic-level-1.3.0.tgz" - integrity sha512-iwFAJQYtqRTRM0F6L8h4JCt00ZSGdOyqh7yVrhhjrOpFhmBjNlRUey64MCiyo6UmQHMJ+No3c81nujPv+n9yrg== - dependencies: - abstract-level "^1.0.2" - catering "^2.1.0" - module-error "^1.0.1" - napi-macros "^2.2.2" - node-gyp-build "^4.3.0" - clean-stack@^2.0.0: version "2.2.0" resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz" @@ -3397,6 +3209,11 @@ clean-stack@^4.0.0: dependencies: escape-string-regexp "5.0.0" +cli-boxes@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/cli-boxes/-/cli-boxes-2.2.1.tgz#ddd5035d25094fce220e9cab40a45840a440318f" + integrity sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw== + cli-cursor@^3.1.0: version "3.1.0" resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz" @@ -3534,11 +3351,6 @@ command-line-usage@^6.1.0: table-layout "^1.0.2" typical "^5.2.0" -commander@3.0.2: - version "3.0.2" - resolved "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz" - integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow== - commander@^10.0.0: version "10.0.1" resolved "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz" @@ -4747,42 +4559,6 @@ ethers@^4.0.40: uuid "2.0.1" xmlhttprequest "1.8.0" -ethers@^5.7.1: - version "5.7.2" - resolved "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz" - integrity sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg== - dependencies: - "@ethersproject/abi" "5.7.0" - "@ethersproject/abstract-provider" "5.7.0" - "@ethersproject/abstract-signer" "5.7.0" - "@ethersproject/address" "5.7.0" - "@ethersproject/base64" "5.7.0" - "@ethersproject/basex" "5.7.0" - "@ethersproject/bignumber" "5.7.0" - "@ethersproject/bytes" "5.7.0" - "@ethersproject/constants" "5.7.0" - "@ethersproject/contracts" "5.7.0" - "@ethersproject/hash" "5.7.0" - "@ethersproject/hdnode" "5.7.0" - "@ethersproject/json-wallets" "5.7.0" - "@ethersproject/keccak256" "5.7.0" - "@ethersproject/logger" "5.7.0" - "@ethersproject/networks" "5.7.1" - "@ethersproject/pbkdf2" "5.7.0" - "@ethersproject/properties" "5.7.0" - "@ethersproject/providers" "5.7.2" - "@ethersproject/random" "5.7.0" - "@ethersproject/rlp" "5.7.0" - "@ethersproject/sha2" "5.7.0" - "@ethersproject/signing-key" "5.7.0" - "@ethersproject/solidity" "5.7.0" - "@ethersproject/strings" "5.7.0" - "@ethersproject/transactions" "5.7.0" - "@ethersproject/units" "5.7.0" - "@ethersproject/wallet" "5.7.0" - "@ethersproject/web" "5.7.1" - "@ethersproject/wordlists" "5.7.0" - ethjs-unit@0.1.6: version "0.1.6" resolved "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz" @@ -4799,11 +4575,6 @@ ethjs-util@0.1.6, ethjs-util@^0.1.3, ethjs-util@^0.1.6: is-hex-prefixed "1.0.0" strip-hex-prefix "1.0.0" -event-target-shim@^5.0.0: - version "5.0.1" - resolved "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz" - integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== - evp_bytestokey@^1.0.3: version "1.0.3" resolved "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz" @@ -5171,17 +4942,6 @@ fragment-cache@^0.2.1: dependencies: map-cache "^0.2.2" -fs-extra@^0.30.0: - version "0.30.0" - resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz" - integrity sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA== - dependencies: - graceful-fs "^4.1.2" - jsonfile "^2.1.0" - klaw "^1.0.0" - path-is-absolute "^1.0.0" - rimraf "^2.2.8" - fs-extra@^7.0.0, fs-extra@^7.0.1: version "7.0.1" resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz" @@ -5574,7 +5334,7 @@ graceful-fs@4.2.10: resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz" integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== -graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.5, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4: +graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.5, graceful-fs@^4.1.6, graceful-fs@^4.2.0, graceful-fs@^4.2.10, graceful-fs@^4.2.4: version "4.2.11" resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz" integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== @@ -5636,31 +5396,25 @@ hardhat-gas-reporter@^1.0.9: eth-gas-reporter "^0.2.25" sha1 "^1.1.1" -hardhat@^2.13.1: - version "2.13.1" - resolved "https://registry.npmjs.org/hardhat/-/hardhat-2.13.1.tgz" - integrity sha512-ZZL7LQxHmbw4JQJsiEv2qE35nbR+isr2sIdtgZVPp0+zWqRkpr1OT7gmvhCNYfjpEPyfjZIxWriQWlphJhVPLQ== +hardhat@^2.17.2: + version "2.22.6" + resolved "https://registry.yarnpkg.com/hardhat/-/hardhat-2.22.6.tgz#d73caece246cd8219a1815554dabc31d400fa035" + integrity sha512-abFEnd9QACwEtSvZZGSmzvw7N3zhQN1cDKz5SLHAupfG24qTHofCjqvD5kT5Wwsq5XOL0ON1Mq5rr4v0XX5ciw== dependencies: "@ethersproject/abi" "^5.1.2" "@metamask/eth-sig-util" "^4.0.0" - "@nomicfoundation/ethereumjs-block" "5.0.0" - "@nomicfoundation/ethereumjs-blockchain" "7.0.0" - "@nomicfoundation/ethereumjs-common" "4.0.0" - "@nomicfoundation/ethereumjs-evm" "2.0.0" - "@nomicfoundation/ethereumjs-rlp" "5.0.0" - "@nomicfoundation/ethereumjs-statemanager" "2.0.0" - "@nomicfoundation/ethereumjs-trie" "6.0.0" - "@nomicfoundation/ethereumjs-tx" "5.0.0" - "@nomicfoundation/ethereumjs-util" "9.0.0" - "@nomicfoundation/ethereumjs-vm" "7.0.0" + "@nomicfoundation/edr" "^0.4.1" + "@nomicfoundation/ethereumjs-common" "4.0.4" + "@nomicfoundation/ethereumjs-tx" "5.0.4" + "@nomicfoundation/ethereumjs-util" "9.0.4" "@nomicfoundation/solidity-analyzer" "^0.1.0" "@sentry/node" "^5.18.1" "@types/bn.js" "^5.1.0" "@types/lru-cache" "^5.1.0" - abort-controller "^3.0.0" adm-zip "^0.4.16" aggregate-error "^3.0.0" ansi-escapes "^4.3.0" + boxen "^5.1.2" chalk "^2.4.2" chokidar "^3.4.0" ci-info "^2.0.0" @@ -5680,11 +5434,10 @@ hardhat@^2.13.1: mnemonist "^0.38.0" mocha "^10.0.0" p-map "^4.0.0" - qs "^6.7.0" raw-body "^2.4.1" resolve "1.17.0" semver "^6.3.0" - solc "0.7.3" + solc "0.8.26" source-map-support "^0.5.13" stacktrace-parser "^0.1.10" tsort "0.0.1" @@ -6582,13 +6335,6 @@ json5@^1.0.2: dependencies: minimist "^1.2.0" -jsonfile@^2.1.0: - version "2.4.0" - resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz" - integrity sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw== - optionalDependencies: - graceful-fs "^4.1.6" - jsonfile@^4.0.0: version "4.0.0" resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz" @@ -6687,13 +6433,6 @@ kind-of@^6.0.0, kind-of@^6.0.2, kind-of@^6.0.3: resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz" integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw== -klaw@^1.0.0: - version "1.3.1" - resolved "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz" - integrity sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw== - optionalDependencies: - graceful-fs "^4.1.9" - kleur@^4.1.5: version "4.1.5" resolved "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz" @@ -6762,11 +6501,6 @@ level-supports@^2.0.1: resolved "https://registry.npmjs.org/level-supports/-/level-supports-2.1.0.tgz" integrity sha512-E486g1NCjW5cF78KGPrMDRBYzPuueMZ6VBXHT6gC7A8UYWGiM14fGgp+s/L1oFfDWSPV/+SFkYCmZ0SiESkRKA== -level-supports@^4.0.0: - version "4.0.1" - resolved "https://registry.npmjs.org/level-supports/-/level-supports-4.0.1.tgz" - integrity sha512-PbXpve8rKeNcZ9C1mUicC9auIYFyGpkV9/i6g76tLgANwWhtG2v7I4xNBUlkn3lE2/dZF3Pi0ygYGtLc4RXXdA== - level-supports@~1.0.0: version "1.0.1" resolved "https://registry.npmjs.org/level-supports/-/level-supports-1.0.1.tgz" @@ -6774,14 +6508,6 @@ level-supports@~1.0.0: dependencies: xtend "^4.0.2" -level-transcoder@^1.0.1: - version "1.0.1" - resolved "https://registry.npmjs.org/level-transcoder/-/level-transcoder-1.0.1.tgz" - integrity sha512-t7bFwFtsQeD8cl8NIoQ2iwxA0CL/9IFw7/9gAjOonH0PWTTiRfY7Hq+Ejbsxh86tXobDQ6IOiddjNYIfOBs06w== - dependencies: - buffer "^6.0.3" - module-error "^1.0.1" - level-ws@^2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/level-ws/-/level-ws-2.0.0.tgz" @@ -6791,14 +6517,6 @@ level-ws@^2.0.0: readable-stream "^3.1.0" xtend "^4.0.1" -level@^8.0.0: - version "8.0.0" - resolved "https://registry.npmjs.org/level/-/level-8.0.0.tgz" - integrity sha512-ypf0jjAk2BWI33yzEaaotpq7fkOPALKAgDBxggO6Q9HGX2MRXn0wbP1Jn/tJv1gtL867+YOjOB49WaUF3UoJNQ== - dependencies: - browser-level "^1.0.1" - classic-level "^1.2.0" - leveldown@6.1.0: version "6.1.0" resolved "https://registry.npmjs.org/leveldown/-/leveldown-6.1.0.tgz" @@ -7032,15 +6750,6 @@ memdown@^5.0.0: ltgt "~2.2.0" safe-buffer "~5.2.0" -memory-level@^1.0.0: - version "1.0.0" - resolved "https://registry.npmjs.org/memory-level/-/memory-level-1.0.0.tgz" - integrity sha512-UXzwewuWeHBz5krr7EvehKcmLFNoXxGcvuYhC41tRnkrTbJohtS7kVn9akmgirtRygg+f7Yjsfi8Uu5SGSQ4Og== - dependencies: - abstract-level "^1.0.0" - functional-red-black-tree "^1.0.1" - module-error "^1.0.1" - memorystream@^0.3.1: version "0.3.1" resolved "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz" @@ -7337,11 +7046,6 @@ mocha@^7.1.1: yargs-parser "13.1.2" yargs-unparser "1.6.0" -module-error@^1.0.1, module-error@^1.0.2: - version "1.0.2" - resolved "https://registry.npmjs.org/module-error/-/module-error-1.0.2.tgz" - integrity sha512-0yuvsqSCv8LbaOKhnsQ/T5JhyFlCYLPXK3U2sgV10zoKQwzs/MyfuQUOZQ1V/6OCOJsK/TRgNVrPuPDqtdMFtA== - ms@2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz" @@ -7394,11 +7098,6 @@ nanomatch@^1.2.9: snapdragon "^0.8.1" to-regex "^3.0.1" -napi-macros@^2.2.2: - version "2.2.2" - resolved "https://registry.npmjs.org/napi-macros/-/napi-macros-2.2.2.tgz" - integrity sha512-hmEVtAGYzVQpCKdbQea4skABsdXW4RUh5t5mJ2zzqowJS2OyXZTU1KhDVFhx+NlWZ4ap9mqR9TcDO3LTTttd+g== - napi-macros@~2.0.0: version "2.0.0" resolved "https://registry.npmjs.org/napi-macros/-/napi-macros-2.0.0.tgz" @@ -8026,7 +7725,7 @@ punycode@^2.1.0, punycode@^2.1.1: resolved "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz" integrity sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA== -qs@^6.4.0, qs@^6.7.0: +qs@^6.4.0: version "6.11.1" resolved "https://registry.npmjs.org/qs/-/qs-6.11.1.tgz" integrity sha512-0wsrzgTz/kAVIeuxSjnpGC56rzYtr6JT/2BwEvMaPhFIoYa1aGO8LbzuU1R0uUYQkLpWBTOj0l/CLAJB64J6nQ== @@ -8366,7 +8065,7 @@ require-directory@^2.1.1: resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz" integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== -require-from-string@^2.0.0, require-from-string@^2.0.2: +require-from-string@^2.0.2: version "2.0.2" resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz" integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== @@ -8471,7 +8170,7 @@ reusify@^1.0.4: resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz" integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== -rimraf@^2.2.8, rimraf@^2.6.2: +rimraf@^2.6.2: version "2.7.1" resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz" integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w== @@ -8512,13 +8211,6 @@ run-async@^2.4.0: resolved "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz" integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ== -run-parallel-limit@^1.1.0: - version "1.1.0" - resolved "https://registry.npmjs.org/run-parallel-limit/-/run-parallel-limit-1.1.0.tgz" - integrity sha512-jJA7irRNM91jaKc3Hcl1npHsFLOXOoTkPCUL1JEa1R82O2miplXXRaGdjW/KM/98YQWDhJLiSs793CnXfblJUw== - dependencies: - queue-microtask "^1.2.2" - run-parallel@^1.1.9: version "1.2.0" resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz" @@ -8868,25 +8560,23 @@ snapdragon@^0.8.1: source-map-resolve "^0.5.0" use "^3.1.0" -solc@0.7.3: - version "0.7.3" - resolved "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz" - integrity sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA== +solc@0.8.15: + version "0.8.15" + resolved "https://registry.npmjs.org/solc/-/solc-0.8.15.tgz" + integrity sha512-Riv0GNHNk/SddN/JyEuFKwbcWcEeho15iyupTSHw5Np6WuXA5D8kEHbyzDHi6sqmvLzu2l+8b1YmL8Ytple+8w== dependencies: command-exists "^1.2.8" - commander "3.0.2" + commander "^8.1.0" follow-redirects "^1.12.1" - fs-extra "^0.30.0" js-sha3 "0.8.0" memorystream "^0.3.1" - require-from-string "^2.0.0" semver "^5.5.0" tmp "0.0.33" -solc@0.8.15: - version "0.8.15" - resolved "https://registry.npmjs.org/solc/-/solc-0.8.15.tgz" - integrity sha512-Riv0GNHNk/SddN/JyEuFKwbcWcEeho15iyupTSHw5Np6WuXA5D8kEHbyzDHi6sqmvLzu2l+8b1YmL8Ytple+8w== +solc@0.8.26: + version "0.8.26" + resolved "https://registry.yarnpkg.com/solc/-/solc-0.8.26.tgz#afc78078953f6ab3e727c338a2fefcd80dd5b01a" + integrity sha512-yiPQNVf5rBFHwN6SIf3TUUvVAFKcQqmSUFeq+fb6pNRCo0ZCgpYOZDi3BVoezCPIAcKrVYd/qXlBLUP9wVrZ9g== dependencies: command-exists "^1.2.8" commander "^8.1.0" @@ -9120,7 +8810,7 @@ string-width@^3.0.0, string-width@^3.1.0: is-fullwidth-code-point "^2.0.0" strip-ansi "^5.1.0" -string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: +string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3: version "4.2.3" resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== @@ -9982,6 +9672,13 @@ wide-align@1.1.3: dependencies: string-width "^1.0.2 || 2" +widest-line@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/widest-line/-/widest-line-3.1.0.tgz#8292333bbf66cb45ff0de1603b136b7ae1496eca" + integrity sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg== + dependencies: + string-width "^4.0.0" + word-wrap@^1.2.3, word-wrap@~1.2.3: version "1.2.3" resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz" From 86b4d7779ef0d1f973d0dc1280f0fe3c618363d8 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 8 Jul 2024 17:46:06 +0200 Subject: [PATCH 59/86] yarn gen --- package.json | 2 +- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../evm/gatewayevm.sol/gatewayevm.go | 2 +- .../evm/gatewayevm.t.sol/gatewayevmtest.go | 4753 +++++ .../evm/interfaces.sol/igatewayevm.go | 44 +- .../evm/interfaces.sol/igatewayevmerrors.go | 181 + .../evm/interfaces.sol/igatewayevmevents.go | 792 + .../evm/interfaces.sol/ireceiverevmevents.go | 727 + pkg/forge-std/base.sol/commonbase.go | 181 + pkg/forge-std/base.sol/scriptbase.go | 181 + pkg/forge-std/base.sol/testbase.go | 181 + pkg/forge-std/console.sol/console.go | 203 + .../interfaces/ierc165.sol/ierc165.go | 212 + pkg/forge-std/interfaces/ierc20.sol/ierc20.go | 738 + .../interfaces/ierc721.sol/ierc721.go | 919 + .../ierc721.sol/ierc721enumerable.go | 1012 + .../interfaces/ierc721.sol/ierc721metadata.go | 1012 + .../ierc721.sol/ierc721tokenreceiver.go | 202 + .../interfaces/imulticall3.sol/imulticall3.go | 644 + .../mocks/mockerc20.sol/mockerc20.go | 864 + .../mocks/mockerc721.sol/mockerc721.go | 1055 + pkg/forge-std/safeconsole.sol/safeconsole.go | 203 + .../stdassertions.sol/stdassertions.go | 3173 +++ pkg/forge-std/stdchains.sol/stdchains.go | 181 + pkg/forge-std/stdcheats.sol/stdcheats.go | 181 + pkg/forge-std/stdcheats.sol/stdcheatssafe.go | 181 + pkg/forge-std/stderror.sol/stderror.go | 482 + .../stdinvariant.sol/stdinvariant.go | 509 + pkg/forge-std/stdjson.sol/stdjson.go | 203 + pkg/forge-std/stdmath.sol/stdmath.go | 203 + pkg/forge-std/stdstorage.sol/stdstorage.go | 203 + .../stdstorage.sol/stdstoragesafe.go | 475 + pkg/forge-std/stdstyle.sol/stdstyle.go | 203 + pkg/forge-std/stdtoml.sol/stdtoml.go | 203 + pkg/forge-std/stdutils.sol/stdutils.go | 181 + pkg/forge-std/test.sol/test.go | 3532 ++++ pkg/forge-std/vm.sol/vm.go | 10783 ++++++++++ pkg/forge-std/vm.sol/vmsafe.go | 9136 +++++++++ .../evm/GatewayEVM.t.sol/GatewayEVMTest.ts | 1023 + .../prototypes/evm/GatewayEVM.t.sol/index.ts | 4 + .../contracts/prototypes/evm/index.ts | 2 + .../evm/interfaces.sol/IGatewayEVM.ts | 87 +- .../evm/interfaces.sol/IGatewayEVMErrors.ts | 56 + .../evm/interfaces.sol/IGatewayEVMEvents.ts | 165 + .../evm/interfaces.sol/IReceiverEVMEvents.ts | 162 + .../prototypes/evm/interfaces.sol/index.ts | 3 + .../evm/ERC20CustodyNew__factory.ts | 2 +- .../GatewayEVMTest__factory.ts | 910 + .../prototypes/evm/GatewayEVM.t.sol/index.ts | 4 + .../prototypes/evm/GatewayEVM__factory.ts | 2 +- .../contracts/prototypes/evm/index.ts | 1 + .../IGatewayEVMErrors__factory.ts | 61 + .../IGatewayEVMEvents__factory.ts | 144 + .../interfaces.sol/IGatewayEVM__factory.ts | 41 - .../IReceiverEVMEvents__factory.ts | 138 + .../prototypes/evm/interfaces.sol/index.ts | 3 + .../forge-std/StdAssertions__factory.ts | 403 + .../StdError.sol/StdError__factory.ts | 180 + .../factories/forge-std/StdError.sol/index.ts | 4 + .../forge-std/StdInvariant__factory.ts | 204 + .../StdStorage.sol/StdStorageSafe__factory.ts | 113 + .../forge-std/StdStorage.sol/index.ts | 4 + .../factories/forge-std/Test__factory.ts | 588 + .../forge-std/Vm.sol/VmSafe__factory.ts | 7315 +++++++ .../factories/forge-std/Vm.sol/Vm__factory.ts | 8645 +++++++++ .../factories/forge-std/Vm.sol/index.ts | 5 + typechain-types/factories/forge-std/index.ts | 11 + .../forge-std/interfaces/IERC165__factory.ts | 45 + .../forge-std/interfaces/IERC20__factory.ts | 245 + .../IERC721.sol/IERC721Enumerable__factory.ts | 367 + .../IERC721.sol/IERC721Metadata__factory.ts | 356 + .../IERC721TokenReceiver__factory.ts | 64 + .../IERC721.sol/IERC721__factory.ts | 311 + .../forge-std/interfaces/IERC721.sol/index.ts | 7 + .../interfaces/IMulticall3__factory.ts | 464 + .../factories/forge-std/interfaces/index.ts | 7 + .../forge-std/mocks/MockERC20__factory.ts | 383 + .../forge-std/mocks/MockERC721__factory.ts | 411 + .../factories/forge-std/mocks/index.ts | 5 + typechain-types/factories/index.ts | 1 + typechain-types/forge-std/StdAssertions.ts | 457 + .../forge-std/StdError.sol/StdError.ts | 249 + .../forge-std/StdError.sol/index.ts | 4 + typechain-types/forge-std/StdInvariant.ts | 357 + .../StdStorage.sol/StdStorageSafe.ts | 109 + .../forge-std/StdStorage.sol/index.ts | 4 + typechain-types/forge-std/Test.ts | 760 + typechain-types/forge-std/Vm.sol/Vm.ts | 16207 ++++++++++++++++ typechain-types/forge-std/Vm.sol/VmSafe.ts | 13288 +++++++++++++ typechain-types/forge-std/Vm.sol/index.ts | 5 + typechain-types/forge-std/index.ts | 16 + .../forge-std/interfaces/IERC165.ts | 103 + .../forge-std/interfaces/IERC20.ts | 384 + .../interfaces/IERC721.sol/IERC721.ts | 560 + .../IERC721.sol/IERC721Enumerable.ts | 655 + .../interfaces/IERC721.sol/IERC721Metadata.ts | 620 + .../IERC721.sol/IERC721TokenReceiver.ts | 126 + .../forge-std/interfaces/IERC721.sol/index.ts | 7 + .../forge-std/interfaces/IMulticall3.ts | 598 + typechain-types/forge-std/interfaces/index.ts | 8 + typechain-types/forge-std/mocks/MockERC20.ts | 552 + typechain-types/forge-std/mocks/MockERC721.ts | 657 + typechain-types/forge-std/mocks/index.ts | 5 + typechain-types/hardhat.d.ts | 180 + typechain-types/index.ts | 40 + 105 files changed, 102661 insertions(+), 175 deletions(-) create mode 100644 pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go create mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go create mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go create mode 100644 pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go create mode 100644 pkg/forge-std/base.sol/commonbase.go create mode 100644 pkg/forge-std/base.sol/scriptbase.go create mode 100644 pkg/forge-std/base.sol/testbase.go create mode 100644 pkg/forge-std/console.sol/console.go create mode 100644 pkg/forge-std/interfaces/ierc165.sol/ierc165.go create mode 100644 pkg/forge-std/interfaces/ierc20.sol/ierc20.go create mode 100644 pkg/forge-std/interfaces/ierc721.sol/ierc721.go create mode 100644 pkg/forge-std/interfaces/ierc721.sol/ierc721enumerable.go create mode 100644 pkg/forge-std/interfaces/ierc721.sol/ierc721metadata.go create mode 100644 pkg/forge-std/interfaces/ierc721.sol/ierc721tokenreceiver.go create mode 100644 pkg/forge-std/interfaces/imulticall3.sol/imulticall3.go create mode 100644 pkg/forge-std/mocks/mockerc20.sol/mockerc20.go create mode 100644 pkg/forge-std/mocks/mockerc721.sol/mockerc721.go create mode 100644 pkg/forge-std/safeconsole.sol/safeconsole.go create mode 100644 pkg/forge-std/stdassertions.sol/stdassertions.go create mode 100644 pkg/forge-std/stdchains.sol/stdchains.go create mode 100644 pkg/forge-std/stdcheats.sol/stdcheats.go create mode 100644 pkg/forge-std/stdcheats.sol/stdcheatssafe.go create mode 100644 pkg/forge-std/stderror.sol/stderror.go create mode 100644 pkg/forge-std/stdinvariant.sol/stdinvariant.go create mode 100644 pkg/forge-std/stdjson.sol/stdjson.go create mode 100644 pkg/forge-std/stdmath.sol/stdmath.go create mode 100644 pkg/forge-std/stdstorage.sol/stdstorage.go create mode 100644 pkg/forge-std/stdstorage.sol/stdstoragesafe.go create mode 100644 pkg/forge-std/stdstyle.sol/stdstyle.go create mode 100644 pkg/forge-std/stdtoml.sol/stdtoml.go create mode 100644 pkg/forge-std/stdutils.sol/stdutils.go create mode 100644 pkg/forge-std/test.sol/test.go create mode 100644 pkg/forge-std/vm.sol/vm.go create mode 100644 pkg/forge-std/vm.sol/vmsafe.go create mode 100644 typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest.ts create mode 100644 typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents.ts create mode 100644 typechain-types/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory.ts create mode 100644 typechain-types/factories/forge-std/StdAssertions__factory.ts create mode 100644 typechain-types/factories/forge-std/StdError.sol/StdError__factory.ts create mode 100644 typechain-types/factories/forge-std/StdError.sol/index.ts create mode 100644 typechain-types/factories/forge-std/StdInvariant__factory.ts create mode 100644 typechain-types/factories/forge-std/StdStorage.sol/StdStorageSafe__factory.ts create mode 100644 typechain-types/factories/forge-std/StdStorage.sol/index.ts create mode 100644 typechain-types/factories/forge-std/Test__factory.ts create mode 100644 typechain-types/factories/forge-std/Vm.sol/VmSafe__factory.ts create mode 100644 typechain-types/factories/forge-std/Vm.sol/Vm__factory.ts create mode 100644 typechain-types/factories/forge-std/Vm.sol/index.ts create mode 100644 typechain-types/factories/forge-std/index.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC165__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC20__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Enumerable__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Metadata__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IERC721.sol/index.ts create mode 100644 typechain-types/factories/forge-std/interfaces/IMulticall3__factory.ts create mode 100644 typechain-types/factories/forge-std/interfaces/index.ts create mode 100644 typechain-types/factories/forge-std/mocks/MockERC20__factory.ts create mode 100644 typechain-types/factories/forge-std/mocks/MockERC721__factory.ts create mode 100644 typechain-types/factories/forge-std/mocks/index.ts create mode 100644 typechain-types/forge-std/StdAssertions.ts create mode 100644 typechain-types/forge-std/StdError.sol/StdError.ts create mode 100644 typechain-types/forge-std/StdError.sol/index.ts create mode 100644 typechain-types/forge-std/StdInvariant.ts create mode 100644 typechain-types/forge-std/StdStorage.sol/StdStorageSafe.ts create mode 100644 typechain-types/forge-std/StdStorage.sol/index.ts create mode 100644 typechain-types/forge-std/Test.ts create mode 100644 typechain-types/forge-std/Vm.sol/Vm.ts create mode 100644 typechain-types/forge-std/Vm.sol/VmSafe.ts create mode 100644 typechain-types/forge-std/Vm.sol/index.ts create mode 100644 typechain-types/forge-std/index.ts create mode 100644 typechain-types/forge-std/interfaces/IERC165.ts create mode 100644 typechain-types/forge-std/interfaces/IERC20.ts create mode 100644 typechain-types/forge-std/interfaces/IERC721.sol/IERC721.ts create mode 100644 typechain-types/forge-std/interfaces/IERC721.sol/IERC721Enumerable.ts create mode 100644 typechain-types/forge-std/interfaces/IERC721.sol/IERC721Metadata.ts create mode 100644 typechain-types/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver.ts create mode 100644 typechain-types/forge-std/interfaces/IERC721.sol/index.ts create mode 100644 typechain-types/forge-std/interfaces/IMulticall3.ts create mode 100644 typechain-types/forge-std/interfaces/index.ts create mode 100644 typechain-types/forge-std/mocks/MockERC20.ts create mode 100644 typechain-types/forge-std/mocks/MockERC721.ts create mode 100644 typechain-types/forge-std/mocks/index.ts diff --git a/package.json b/package.json index ffcf9bc8..42165105 100644 --- a/package.json +++ b/package.json @@ -84,7 +84,7 @@ "docs": "forge doc", "generate": "yarn compile && ./scripts/generate_go.sh || true && ./scripts/generate_addresses.sh && yarn lint:fix", "lint": "npx eslint . --ext .js,.ts", - "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json", + "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json --ignore-pattern lib/forge-std/ --ignore-pattern out", "lint:sol": "solhint 'contracts/**/*.sol'", "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"", "prepublishOnly": "yarn build", diff --git a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index 18cbbbc4..369c9690 100644 --- a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 374ca35b..db197e19 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -32,7 +32,7 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go new file mode 100644 index 00000000..69483950 --- /dev/null +++ b/pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go @@ -0,0 +1,4753 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayevm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdInvariantFuzzArtifactSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzArtifactSelector struct { + Artifact string + Selectors [][4]byte +} + +// StdInvariantFuzzInterface is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzInterface struct { + Addr common.Address + Artifacts []string +} + +// StdInvariantFuzzSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzSelector struct { + Addr common.Address + Selectors [][4]byte +} + +// GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. +var GatewayEVMTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayEVMTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMTestMetaData.ABI instead. +var GatewayEVMTestABI = GatewayEVMTestMetaData.ABI + +// GatewayEVMTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMTestMetaData.Bin instead. +var GatewayEVMTestBin = GatewayEVMTestMetaData.Bin + +// DeployGatewayEVMTest deploys a new Ethereum contract, binding an instance of GatewayEVMTest to it. +func DeployGatewayEVMTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVMTest, error) { + parsed, err := GatewayEVMTestMetaData.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(GatewayEVMTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayEVMTest{GatewayEVMTestCaller: GatewayEVMTestCaller{contract: contract}, GatewayEVMTestTransactor: GatewayEVMTestTransactor{contract: contract}, GatewayEVMTestFilterer: GatewayEVMTestFilterer{contract: contract}}, nil +} + +// GatewayEVMTest is an auto generated Go binding around an Ethereum contract. +type GatewayEVMTest struct { + GatewayEVMTestCaller // Read-only binding to the contract + GatewayEVMTestTransactor // Write-only binding to the contract + GatewayEVMTestFilterer // Log filterer for contract events +} + +// GatewayEVMTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayEVMTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayEVMTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayEVMTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayEVMTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayEVMTestSession struct { + Contract *GatewayEVMTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayEVMTestCallerSession struct { + Contract *GatewayEVMTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayEVMTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayEVMTestTransactorSession struct { + Contract *GatewayEVMTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayEVMTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayEVMTestRaw struct { + Contract *GatewayEVMTest // Generic contract binding to access the raw methods on +} + +// GatewayEVMTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayEVMTestCallerRaw struct { + Contract *GatewayEVMTestCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayEVMTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayEVMTestTransactorRaw struct { + Contract *GatewayEVMTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayEVMTest creates a new instance of GatewayEVMTest, bound to a specific deployed contract. +func NewGatewayEVMTest(address common.Address, backend bind.ContractBackend) (*GatewayEVMTest, error) { + contract, err := bindGatewayEVMTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayEVMTest{GatewayEVMTestCaller: GatewayEVMTestCaller{contract: contract}, GatewayEVMTestTransactor: GatewayEVMTestTransactor{contract: contract}, GatewayEVMTestFilterer: GatewayEVMTestFilterer{contract: contract}}, nil +} + +// NewGatewayEVMTestCaller creates a new read-only instance of GatewayEVMTest, bound to a specific deployed contract. +func NewGatewayEVMTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMTestCaller, error) { + contract, err := bindGatewayEVMTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayEVMTestCaller{contract: contract}, nil +} + +// NewGatewayEVMTestTransactor creates a new write-only instance of GatewayEVMTest, bound to a specific deployed contract. +func NewGatewayEVMTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMTestTransactor, error) { + contract, err := bindGatewayEVMTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayEVMTestTransactor{contract: contract}, nil +} + +// NewGatewayEVMTestFilterer creates a new log filterer instance of GatewayEVMTest, bound to a specific deployed contract. +func NewGatewayEVMTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMTestFilterer, error) { + contract, err := bindGatewayEVMTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayEVMTestFilterer{contract: contract}, nil +} + +// bindGatewayEVMTest binds a generic wrapper to an already deployed contract. +func bindGatewayEVMTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayEVMTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMTest *GatewayEVMTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMTest.Contract.GatewayEVMTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMTest *GatewayEVMTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMTest.Contract.GatewayEVMTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMTest *GatewayEVMTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMTest.Contract.GatewayEVMTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayEVMTest *GatewayEVMTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayEVMTest *GatewayEVMTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayEVMTest *GatewayEVMTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMTest.Contract.contract.Transact(opts, method, params...) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "IS_TEST") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestSession) ISTEST() (bool, error) { + return _GatewayEVMTest.Contract.ISTEST(&_GatewayEVMTest.CallOpts) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) ISTEST() (bool, error) { + return _GatewayEVMTest.Contract.ISTEST(&_GatewayEVMTest.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "excludeArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestSession) ExcludeArtifacts() ([]string, error) { + return _GatewayEVMTest.Contract.ExcludeArtifacts(&_GatewayEVMTest.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) ExcludeArtifacts() ([]string, error) { + return _GatewayEVMTest.Contract.ExcludeArtifacts(&_GatewayEVMTest.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayEVMTest *GatewayEVMTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "excludeContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayEVMTest *GatewayEVMTestSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayEVMTest.Contract.ExcludeContracts(&_GatewayEVMTest.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayEVMTest.Contract.ExcludeContracts(&_GatewayEVMTest.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "excludeSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMTest.Contract.ExcludeSelectors(&_GatewayEVMTest.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMTest.Contract.ExcludeSelectors(&_GatewayEVMTest.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayEVMTest *GatewayEVMTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "excludeSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayEVMTest *GatewayEVMTestSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayEVMTest.Contract.ExcludeSenders(&_GatewayEVMTest.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayEVMTest.Contract.ExcludeSenders(&_GatewayEVMTest.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestCaller) Failed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "failed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestSession) Failed() (bool, error) { + return _GatewayEVMTest.Contract.Failed(&_GatewayEVMTest.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) Failed() (bool, error) { + return _GatewayEVMTest.Contract.Failed(&_GatewayEVMTest.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetArtifactSelectors") + + if err != nil { + return *new([]StdInvariantFuzzArtifactSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector) + + return out0, err + +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayEVMTest.Contract.TargetArtifactSelectors(&_GatewayEVMTest.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayEVMTest.Contract.TargetArtifactSelectors(&_GatewayEVMTest.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetArtifacts() ([]string, error) { + return _GatewayEVMTest.Contract.TargetArtifacts(&_GatewayEVMTest.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetArtifacts() ([]string, error) { + return _GatewayEVMTest.Contract.TargetArtifacts(&_GatewayEVMTest.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetContracts() ([]common.Address, error) { + return _GatewayEVMTest.Contract.TargetContracts(&_GatewayEVMTest.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetContracts() ([]common.Address, error) { + return _GatewayEVMTest.Contract.TargetContracts(&_GatewayEVMTest.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetInterfaces") + + if err != nil { + return *new([]StdInvariantFuzzInterface), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface) + + return out0, err + +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayEVMTest.Contract.TargetInterfaces(&_GatewayEVMTest.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayEVMTest.Contract.TargetInterfaces(&_GatewayEVMTest.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMTest.Contract.TargetSelectors(&_GatewayEVMTest.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMTest.Contract.TargetSelectors(&_GatewayEVMTest.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayEVMTest *GatewayEVMTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayEVMTest.contract.Call(opts, &out, "targetSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayEVMTest *GatewayEVMTestSession) TargetSenders() ([]common.Address, error) { + return _GatewayEVMTest.Contract.TargetSenders(&_GatewayEVMTest.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayEVMTest *GatewayEVMTestCallerSession) TargetSenders() ([]common.Address, error) { + return _GatewayEVMTest.Contract.TargetSenders(&_GatewayEVMTest.CallOpts) +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayEVMTest *GatewayEVMTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMTest.contract.Transact(opts, "setUp") +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayEVMTest *GatewayEVMTestSession) SetUp() (*types.Transaction, error) { + return _GatewayEVMTest.Contract.SetUp(&_GatewayEVMTest.TransactOpts) +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayEVMTest *GatewayEVMTestTransactorSession) SetUp() (*types.Transaction, error) { + return _GatewayEVMTest.Contract.SetUp(&_GatewayEVMTest.TransactOpts) +} + +// TestForwardCallToReceivePayable is a paid mutator transaction binding the contract method 0xfe7bdbb2. +// +// Solidity: function testForwardCallToReceivePayable() returns() +func (_GatewayEVMTest *GatewayEVMTestTransactor) TestForwardCallToReceivePayable(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMTest.contract.Transact(opts, "testForwardCallToReceivePayable") +} + +// TestForwardCallToReceivePayable is a paid mutator transaction binding the contract method 0xfe7bdbb2. +// +// Solidity: function testForwardCallToReceivePayable() returns() +func (_GatewayEVMTest *GatewayEVMTestSession) TestForwardCallToReceivePayable() (*types.Transaction, error) { + return _GatewayEVMTest.Contract.TestForwardCallToReceivePayable(&_GatewayEVMTest.TransactOpts) +} + +// TestForwardCallToReceivePayable is a paid mutator transaction binding the contract method 0xfe7bdbb2. +// +// Solidity: function testForwardCallToReceivePayable() returns() +func (_GatewayEVMTest *GatewayEVMTestTransactorSession) TestForwardCallToReceivePayable() (*types.Transaction, error) { + return _GatewayEVMTest.Contract.TestForwardCallToReceivePayable(&_GatewayEVMTest.TransactOpts) +} + +// GatewayEVMTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVMTest contract. +type GatewayEVMTestCallIterator struct { + Event *GatewayEVMTestCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestCall represents a Call event raised by the GatewayEVMTest contract. +type GatewayEVMTestCall struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMTestCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMTestCallIterator{contract: _GatewayEVMTest.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestCall) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseCall(log types.Log) (*GatewayEVMTestCall, error) { + event := new(GatewayEVMTestCall) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVMTest contract. +type GatewayEVMTestDepositIterator struct { + Event *GatewayEVMTestDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestDeposit represents a Deposit event raised by the GatewayEVMTest contract. +type GatewayEVMTestDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMTestDepositIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayEVMTestDepositIterator{contract: _GatewayEVMTest.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestDeposit) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseDeposit(log types.Log) (*GatewayEVMTestDeposit, error) { + event := new(GatewayEVMTestDeposit) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVMTest contract. +type GatewayEVMTestExecutedIterator struct { + Event *GatewayEVMTestExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestExecuted represents a Executed event raised by the GatewayEVMTest contract. +type GatewayEVMTestExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMTestExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &GatewayEVMTestExecutedIterator{contract: _GatewayEVMTest.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestExecuted) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseExecuted(log types.Log) (*GatewayEVMTestExecuted, error) { + event := new(GatewayEVMTestExecuted) + if err := _GatewayEVMTest.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMTest contract. +type GatewayEVMTestExecutedWithERC20Iterator struct { + Event *GatewayEVMTestExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMTest contract. +type GatewayEVMTestExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMTestExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayEVMTestExecutedWithERC20Iterator{contract: _GatewayEVMTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestExecutedWithERC20) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMTestExecutedWithERC20, error) { + event := new(GatewayEVMTestExecutedWithERC20) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedERC20Iterator struct { + Event *GatewayEVMTestReceivedERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestReceivedERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestReceivedERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestReceivedERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestReceivedERC20 represents a ReceivedERC20 event raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedERC20 struct { + Sender common.Address + Amount *big.Int + Token common.Address + Destination common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*GatewayEVMTestReceivedERC20Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return &GatewayEVMTestReceivedERC20Iterator{contract: _GatewayEVMTest.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil +} + +// WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestReceivedERC20) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestReceivedERC20) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedERC20", 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 +} + +// ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseReceivedERC20(log types.Log) (*GatewayEVMTestReceivedERC20, error) { + event := new(GatewayEVMTestReceivedERC20) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedNoParamsIterator struct { + Event *GatewayEVMTestReceivedNoParams // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestReceivedNoParamsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestReceivedNoParamsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestReceivedNoParamsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestReceivedNoParams represents a ReceivedNoParams event raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedNoParams struct { + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*GatewayEVMTestReceivedNoParamsIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return &GatewayEVMTestReceivedNoParamsIterator{contract: _GatewayEVMTest.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil +} + +// WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestReceivedNoParams) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestReceivedNoParams) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedNoParams", 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 +} + +// ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseReceivedNoParams(log types.Log) (*GatewayEVMTestReceivedNoParams, error) { + event := new(GatewayEVMTestReceivedNoParams) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedNonPayableIterator struct { + Event *GatewayEVMTestReceivedNonPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestReceivedNonPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestReceivedNonPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestReceivedNonPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestReceivedNonPayable represents a ReceivedNonPayable event raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedNonPayable struct { + Sender common.Address + Strs []string + Nums []*big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*GatewayEVMTestReceivedNonPayableIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return &GatewayEVMTestReceivedNonPayableIterator{contract: _GatewayEVMTest.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestReceivedNonPayable) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestReceivedNonPayable) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedNonPayable", 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 +} + +// ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseReceivedNonPayable(log types.Log) (*GatewayEVMTestReceivedNonPayable, error) { + event := new(GatewayEVMTestReceivedNonPayable) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedPayableIterator struct { + Event *GatewayEVMTestReceivedPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestReceivedPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestReceivedPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestReceivedPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestReceivedPayable represents a ReceivedPayable event raised by the GatewayEVMTest contract. +type GatewayEVMTestReceivedPayable struct { + Sender common.Address + Value *big.Int + Str string + Num *big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*GatewayEVMTestReceivedPayableIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return &GatewayEVMTestReceivedPayableIterator{contract: _GatewayEVMTest.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestReceivedPayable) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestReceivedPayable) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedPayable", 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 +} + +// ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseReceivedPayable(log types.Log) (*GatewayEVMTestReceivedPayable, error) { + event := new(GatewayEVMTestReceivedPayable) + if err := _GatewayEVMTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogIterator struct { + Event *GatewayEVMTestLog // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLog represents a Log event raised by the GatewayEVMTest contract. +type GatewayEVMTestLog struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLog(opts *bind.FilterOpts) (*GatewayEVMTestLogIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogIterator{contract: _GatewayEVMTest.contract, event: "log", logs: logs, sub: sub}, nil +} + +// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLog) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLog) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log", 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 +} + +// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLog(log types.Log) (*GatewayEVMTestLog, error) { + event := new(GatewayEVMTestLog) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogAddressIterator struct { + Event *GatewayEVMTestLogAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogAddress represents a LogAddress event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogAddress struct { + Arg0 common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*GatewayEVMTestLogAddressIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_address") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogAddressIterator{contract: _GatewayEVMTest.contract, event: "log_address", logs: logs, sub: sub}, nil +} + +// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogAddress) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogAddress) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_address", 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 +} + +// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogAddress(log types.Log) (*GatewayEVMTestLogAddress, error) { + event := new(GatewayEVMTestLogAddress) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArrayIterator struct { + Event *GatewayEVMTestLogArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogArray represents a LogArray event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArray struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*GatewayEVMTestLogArrayIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_array") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogArrayIterator{contract: _GatewayEVMTest.contract, event: "log_array", logs: logs, sub: sub}, nil +} + +// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogArray) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogArray) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array", 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 +} + +// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogArray(log types.Log) (*GatewayEVMTestLogArray, error) { + event := new(GatewayEVMTestLogArray) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArray0Iterator struct { + Event *GatewayEVMTestLogArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogArray0 represents a LogArray0 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArray0 struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*GatewayEVMTestLogArray0Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogArray0Iterator{contract: _GatewayEVMTest.contract, event: "log_array0", logs: logs, sub: sub}, nil +} + +// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogArray0) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogArray0) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array0", 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 +} + +// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogArray0(log types.Log) (*GatewayEVMTestLogArray0, error) { + event := new(GatewayEVMTestLogArray0) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArray1Iterator struct { + Event *GatewayEVMTestLogArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogArray1 represents a LogArray1 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogArray1 struct { + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*GatewayEVMTestLogArray1Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogArray1Iterator{contract: _GatewayEVMTest.contract, event: "log_array1", logs: logs, sub: sub}, nil +} + +// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogArray1) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogArray1) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array1", 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 +} + +// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogArray1(log types.Log) (*GatewayEVMTestLogArray1, error) { + event := new(GatewayEVMTestLogArray1) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogBytesIterator struct { + Event *GatewayEVMTestLogBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogBytes represents a LogBytes event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogBytes struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*GatewayEVMTestLogBytesIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogBytesIterator{contract: _GatewayEVMTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogBytes) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogBytes) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_bytes", 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 +} + +// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogBytes(log types.Log) (*GatewayEVMTestLogBytes, error) { + event := new(GatewayEVMTestLogBytes) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogBytes32Iterator struct { + Event *GatewayEVMTestLogBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogBytes32 represents a LogBytes32 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogBytes32 struct { + Arg0 [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*GatewayEVMTestLogBytes32Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogBytes32Iterator{contract: _GatewayEVMTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogBytes32) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogBytes32) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_bytes32", 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 +} + +// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogBytes32(log types.Log) (*GatewayEVMTestLogBytes32, error) { + event := new(GatewayEVMTestLogBytes32) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogIntIterator struct { + Event *GatewayEVMTestLogInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogInt represents a LogInt event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogInt struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*GatewayEVMTestLogIntIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_int") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogIntIterator{contract: _GatewayEVMTest.contract, event: "log_int", logs: logs, sub: sub}, nil +} + +// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogInt) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_int", 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 +} + +// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogInt(log types.Log) (*GatewayEVMTestLogInt, error) { + event := new(GatewayEVMTestLogInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedAddressIterator struct { + Event *GatewayEVMTestLogNamedAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedAddress represents a LogNamedAddress event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedAddress struct { + Key string + Val common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedAddressIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedAddressIterator{contract: _GatewayEVMTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil +} + +// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedAddress) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedAddress) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_address", 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 +} + +// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedAddress(log types.Log) (*GatewayEVMTestLogNamedAddress, error) { + event := new(GatewayEVMTestLogNamedAddress) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArrayIterator struct { + Event *GatewayEVMTestLogNamedArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedArray represents a LogNamedArray event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArray struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedArrayIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedArrayIterator{contract: _GatewayEVMTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedArray) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedArray) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array", 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 +} + +// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedArray(log types.Log) (*GatewayEVMTestLogNamedArray, error) { + event := new(GatewayEVMTestLogNamedArray) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArray0Iterator struct { + Event *GatewayEVMTestLogNamedArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedArray0 represents a LogNamedArray0 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArray0 struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedArray0Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedArray0Iterator{contract: _GatewayEVMTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedArray0) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedArray0) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array0", 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 +} + +// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedArray0(log types.Log) (*GatewayEVMTestLogNamedArray0, error) { + event := new(GatewayEVMTestLogNamedArray0) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArray1Iterator struct { + Event *GatewayEVMTestLogNamedArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedArray1 represents a LogNamedArray1 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedArray1 struct { + Key string + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedArray1Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedArray1Iterator{contract: _GatewayEVMTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedArray1) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedArray1) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array1", 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 +} + +// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedArray1(log types.Log) (*GatewayEVMTestLogNamedArray1, error) { + event := new(GatewayEVMTestLogNamedArray1) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedBytesIterator struct { + Event *GatewayEVMTestLogNamedBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedBytes represents a LogNamedBytes event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedBytes struct { + Key string + Val []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedBytesIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedBytesIterator{contract: _GatewayEVMTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedBytes) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedBytes) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_bytes", 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 +} + +// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedBytes(log types.Log) (*GatewayEVMTestLogNamedBytes, error) { + event := new(GatewayEVMTestLogNamedBytes) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedBytes32Iterator struct { + Event *GatewayEVMTestLogNamedBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedBytes32 struct { + Key string + Val [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedBytes32Iterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedBytes32Iterator{contract: _GatewayEVMTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedBytes32) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedBytes32) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_bytes32", 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 +} + +// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedBytes32(log types.Log) (*GatewayEVMTestLogNamedBytes32, error) { + event := new(GatewayEVMTestLogNamedBytes32) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedDecimalIntIterator struct { + Event *GatewayEVMTestLogNamedDecimalInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedDecimalIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedDecimalIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedDecimalIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedDecimalInt struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedDecimalIntIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedDecimalIntIterator{contract: _GatewayEVMTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedDecimalInt) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedDecimalInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_decimal_int", 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 +} + +// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*GatewayEVMTestLogNamedDecimalInt, error) { + event := new(GatewayEVMTestLogNamedDecimalInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedDecimalUintIterator struct { + Event *GatewayEVMTestLogNamedDecimalUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedDecimalUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedDecimalUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedDecimalUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedDecimalUint struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedDecimalUintIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedDecimalUintIterator{contract: _GatewayEVMTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedDecimalUint) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedDecimalUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_decimal_uint", 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 +} + +// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*GatewayEVMTestLogNamedDecimalUint, error) { + event := new(GatewayEVMTestLogNamedDecimalUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedIntIterator struct { + Event *GatewayEVMTestLogNamedInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedInt represents a LogNamedInt event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedInt struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedIntIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedIntIterator{contract: _GatewayEVMTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedInt) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_int", 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 +} + +// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedInt(log types.Log) (*GatewayEVMTestLogNamedInt, error) { + event := new(GatewayEVMTestLogNamedInt) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedStringIterator struct { + Event *GatewayEVMTestLogNamedString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedString represents a LogNamedString event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedString struct { + Key string + Val string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedStringIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedStringIterator{contract: _GatewayEVMTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil +} + +// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedString) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedString) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_string", 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 +} + +// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedString(log types.Log) (*GatewayEVMTestLogNamedString, error) { + event := new(GatewayEVMTestLogNamedString) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedUintIterator struct { + Event *GatewayEVMTestLogNamedUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogNamedUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogNamedUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogNamedUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogNamedUint represents a LogNamedUint event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogNamedUint struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*GatewayEVMTestLogNamedUintIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogNamedUintIterator{contract: _GatewayEVMTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogNamedUint) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogNamedUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_uint", 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 +} + +// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogNamedUint(log types.Log) (*GatewayEVMTestLogNamedUint, error) { + event := new(GatewayEVMTestLogNamedUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogStringIterator struct { + Event *GatewayEVMTestLogString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogString represents a LogString event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogString struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogString(opts *bind.FilterOpts) (*GatewayEVMTestLogStringIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_string") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogStringIterator{contract: _GatewayEVMTest.contract, event: "log_string", logs: logs, sub: sub}, nil +} + +// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogString) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogString) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_string", 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 +} + +// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogString(log types.Log) (*GatewayEVMTestLogString, error) { + event := new(GatewayEVMTestLogString) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogUintIterator struct { + Event *GatewayEVMTestLogUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogUint represents a LogUint event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogUint struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*GatewayEVMTestLogUintIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogUintIterator{contract: _GatewayEVMTest.contract, event: "log_uint", logs: logs, sub: sub}, nil +} + +// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogUint) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_uint", 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 +} + +// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogUint(log types.Log) (*GatewayEVMTestLogUint, error) { + event := new(GatewayEVMTestLogUint) + if err := _GatewayEVMTest.contract.UnpackLog(event, "log_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayEVMTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the GatewayEVMTest contract. +type GatewayEVMTestLogsIterator struct { + Event *GatewayEVMTestLogs // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMTestLogsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMTestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMTestLogsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMTestLogsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMTestLogs represents a Logs event raised by the GatewayEVMTest contract. +type GatewayEVMTestLogs struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) FilterLogs(opts *bind.FilterOpts) (*GatewayEVMTestLogsIterator, error) { + + logs, sub, err := _GatewayEVMTest.contract.FilterLogs(opts, "logs") + if err != nil { + return nil, err + } + return &GatewayEVMTestLogsIterator{contract: _GatewayEVMTest.contract, event: "logs", logs: logs, sub: sub}, nil +} + +// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *GatewayEVMTestLogs) (event.Subscription, error) { + + logs, sub, err := _GatewayEVMTest.contract.WatchLogs(opts, "logs") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMTestLogs) + if err := _GatewayEVMTest.contract.UnpackLog(event, "logs", 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 +} + +// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayEVMTest *GatewayEVMTestFilterer) ParseLogs(log types.Log) (*GatewayEVMTestLogs, error) { + event := new(GatewayEVMTestLogs) + if err := _GatewayEVMTest.contract.UnpackLog(event, "logs", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go index def1e811..6317820c 100644 --- a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go +++ b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go @@ -31,7 +31,7 @@ var ( // IGatewayEVMMetaData contains all meta data concerning the IGatewayEVM contract. var IGatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", } // IGatewayEVMABI is the input ABI used to generate the binding from. @@ -221,45 +221,3 @@ func (_IGatewayEVM *IGatewayEVMSession) ExecuteWithERC20(token common.Address, t func (_IGatewayEVM *IGatewayEVMTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _IGatewayEVM.Contract.ExecuteWithERC20(&_IGatewayEVM.TransactOpts, token, to, amount, data) } - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_IGatewayEVM *IGatewayEVMTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.contract.Transact(opts, "send", recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_IGatewayEVM *IGatewayEVMSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.Contract.Send(&_IGatewayEVM.TransactOpts, recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_IGatewayEVM *IGatewayEVMTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.Contract.Send(&_IGatewayEVM.TransactOpts, recipient, amount) -} - -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. -// -// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() -func (_IGatewayEVM *IGatewayEVMTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.contract.Transact(opts, "sendERC20", recipient, asset, amount) -} - -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. -// -// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() -func (_IGatewayEVM *IGatewayEVMSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.Contract.SendERC20(&_IGatewayEVM.TransactOpts, recipient, asset, amount) -} - -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. -// -// Solidity: function sendERC20(bytes recipient, address asset, uint256 amount) returns() -func (_IGatewayEVM *IGatewayEVMTransactorSession) SendERC20(recipient []byte, asset common.Address, amount *big.Int) (*types.Transaction, error) { - return _IGatewayEVM.Contract.SendERC20(&_IGatewayEVM.TransactOpts, recipient, asset, amount) -} diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go new file mode 100644 index 00000000..1c913e25 --- /dev/null +++ b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayEVMErrorsMetaData contains all meta data concerning the IGatewayEVMErrors contract. +var IGatewayEVMErrorsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"}]", +} + +// IGatewayEVMErrorsABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayEVMErrorsMetaData.ABI instead. +var IGatewayEVMErrorsABI = IGatewayEVMErrorsMetaData.ABI + +// IGatewayEVMErrors is an auto generated Go binding around an Ethereum contract. +type IGatewayEVMErrors struct { + IGatewayEVMErrorsCaller // Read-only binding to the contract + IGatewayEVMErrorsTransactor // Write-only binding to the contract + IGatewayEVMErrorsFilterer // Log filterer for contract events +} + +// IGatewayEVMErrorsCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayEVMErrorsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMErrorsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayEVMErrorsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMErrorsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayEVMErrorsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMErrorsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayEVMErrorsSession struct { + Contract *IGatewayEVMErrors // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMErrorsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayEVMErrorsCallerSession struct { + Contract *IGatewayEVMErrorsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayEVMErrorsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayEVMErrorsTransactorSession struct { + Contract *IGatewayEVMErrorsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMErrorsRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayEVMErrorsRaw struct { + Contract *IGatewayEVMErrors // Generic contract binding to access the raw methods on +} + +// IGatewayEVMErrorsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayEVMErrorsCallerRaw struct { + Contract *IGatewayEVMErrorsCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayEVMErrorsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayEVMErrorsTransactorRaw struct { + Contract *IGatewayEVMErrorsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayEVMErrors creates a new instance of IGatewayEVMErrors, bound to a specific deployed contract. +func NewIGatewayEVMErrors(address common.Address, backend bind.ContractBackend) (*IGatewayEVMErrors, error) { + contract, err := bindIGatewayEVMErrors(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayEVMErrors{IGatewayEVMErrorsCaller: IGatewayEVMErrorsCaller{contract: contract}, IGatewayEVMErrorsTransactor: IGatewayEVMErrorsTransactor{contract: contract}, IGatewayEVMErrorsFilterer: IGatewayEVMErrorsFilterer{contract: contract}}, nil +} + +// NewIGatewayEVMErrorsCaller creates a new read-only instance of IGatewayEVMErrors, bound to a specific deployed contract. +func NewIGatewayEVMErrorsCaller(address common.Address, caller bind.ContractCaller) (*IGatewayEVMErrorsCaller, error) { + contract, err := bindIGatewayEVMErrors(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMErrorsCaller{contract: contract}, nil +} + +// NewIGatewayEVMErrorsTransactor creates a new write-only instance of IGatewayEVMErrors, bound to a specific deployed contract. +func NewIGatewayEVMErrorsTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayEVMErrorsTransactor, error) { + contract, err := bindIGatewayEVMErrors(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMErrorsTransactor{contract: contract}, nil +} + +// NewIGatewayEVMErrorsFilterer creates a new log filterer instance of IGatewayEVMErrors, bound to a specific deployed contract. +func NewIGatewayEVMErrorsFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayEVMErrorsFilterer, error) { + contract, err := bindIGatewayEVMErrors(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayEVMErrorsFilterer{contract: contract}, nil +} + +// bindIGatewayEVMErrors binds a generic wrapper to an already deployed contract. +func bindIGatewayEVMErrors(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayEVMErrorsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVMErrors *IGatewayEVMErrorsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVMErrors.Contract.IGatewayEVMErrorsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVMErrors *IGatewayEVMErrorsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVMErrors.Contract.IGatewayEVMErrorsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVMErrors *IGatewayEVMErrorsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVMErrors.Contract.IGatewayEVMErrorsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVMErrors *IGatewayEVMErrorsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVMErrors.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVMErrors *IGatewayEVMErrorsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVMErrors.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVMErrors *IGatewayEVMErrorsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVMErrors.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go new file mode 100644 index 00000000..2302001c --- /dev/null +++ b/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go @@ -0,0 +1,792 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayEVMEventsMetaData contains all meta data concerning the IGatewayEVMEvents contract. +var IGatewayEVMEventsMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"}]", +} + +// IGatewayEVMEventsABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayEVMEventsMetaData.ABI instead. +var IGatewayEVMEventsABI = IGatewayEVMEventsMetaData.ABI + +// IGatewayEVMEvents is an auto generated Go binding around an Ethereum contract. +type IGatewayEVMEvents struct { + IGatewayEVMEventsCaller // Read-only binding to the contract + IGatewayEVMEventsTransactor // Write-only binding to the contract + IGatewayEVMEventsFilterer // Log filterer for contract events +} + +// IGatewayEVMEventsCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayEVMEventsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMEventsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayEVMEventsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMEventsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayEVMEventsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayEVMEventsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayEVMEventsSession struct { + Contract *IGatewayEVMEvents // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMEventsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayEVMEventsCallerSession struct { + Contract *IGatewayEVMEventsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayEVMEventsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayEVMEventsTransactorSession struct { + Contract *IGatewayEVMEventsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayEVMEventsRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayEVMEventsRaw struct { + Contract *IGatewayEVMEvents // Generic contract binding to access the raw methods on +} + +// IGatewayEVMEventsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayEVMEventsCallerRaw struct { + Contract *IGatewayEVMEventsCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayEVMEventsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayEVMEventsTransactorRaw struct { + Contract *IGatewayEVMEventsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayEVMEvents creates a new instance of IGatewayEVMEvents, bound to a specific deployed contract. +func NewIGatewayEVMEvents(address common.Address, backend bind.ContractBackend) (*IGatewayEVMEvents, error) { + contract, err := bindIGatewayEVMEvents(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayEVMEvents{IGatewayEVMEventsCaller: IGatewayEVMEventsCaller{contract: contract}, IGatewayEVMEventsTransactor: IGatewayEVMEventsTransactor{contract: contract}, IGatewayEVMEventsFilterer: IGatewayEVMEventsFilterer{contract: contract}}, nil +} + +// NewIGatewayEVMEventsCaller creates a new read-only instance of IGatewayEVMEvents, bound to a specific deployed contract. +func NewIGatewayEVMEventsCaller(address common.Address, caller bind.ContractCaller) (*IGatewayEVMEventsCaller, error) { + contract, err := bindIGatewayEVMEvents(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsCaller{contract: contract}, nil +} + +// NewIGatewayEVMEventsTransactor creates a new write-only instance of IGatewayEVMEvents, bound to a specific deployed contract. +func NewIGatewayEVMEventsTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayEVMEventsTransactor, error) { + contract, err := bindIGatewayEVMEvents(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsTransactor{contract: contract}, nil +} + +// NewIGatewayEVMEventsFilterer creates a new log filterer instance of IGatewayEVMEvents, bound to a specific deployed contract. +func NewIGatewayEVMEventsFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayEVMEventsFilterer, error) { + contract, err := bindIGatewayEVMEvents(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsFilterer{contract: contract}, nil +} + +// bindIGatewayEVMEvents binds a generic wrapper to an already deployed contract. +func bindIGatewayEVMEvents(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayEVMEventsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVMEvents *IGatewayEVMEventsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVMEvents.Contract.IGatewayEVMEventsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVMEvents *IGatewayEVMEventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVMEvents.Contract.IGatewayEVMEventsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVMEvents *IGatewayEVMEventsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVMEvents.Contract.IGatewayEVMEventsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayEVMEvents *IGatewayEVMEventsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayEVMEvents.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayEVMEvents *IGatewayEVMEventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayEVMEvents.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayEVMEvents *IGatewayEVMEventsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayEVMEvents.Contract.contract.Transact(opts, method, params...) +} + +// IGatewayEVMEventsCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsCallIterator struct { + Event *IGatewayEVMEventsCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayEVMEventsCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayEVMEventsCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayEVMEventsCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayEVMEventsCall represents a Call event raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsCall struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*IGatewayEVMEventsCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.FilterLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsCallIterator{contract: _IGatewayEVMEvents.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *IGatewayEVMEventsCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.WatchLogs(opts, "Call", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayEVMEventsCall) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) ParseCall(log types.Log) (*IGatewayEVMEventsCall, error) { + event := new(IGatewayEVMEventsCall) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IGatewayEVMEventsDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsDepositIterator struct { + Event *IGatewayEVMEventsDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayEVMEventsDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayEVMEventsDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayEVMEventsDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayEVMEventsDeposit represents a Deposit event raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*IGatewayEVMEventsDepositIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsDepositIterator{contract: _IGatewayEVMEvents.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *IGatewayEVMEventsDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayEVMEventsDeposit) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) ParseDeposit(log types.Log) (*IGatewayEVMEventsDeposit, error) { + event := new(IGatewayEVMEventsDeposit) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IGatewayEVMEventsExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsExecutedIterator struct { + Event *IGatewayEVMEventsExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayEVMEventsExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayEVMEventsExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayEVMEventsExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayEVMEventsExecuted represents a Executed event raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*IGatewayEVMEventsExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsExecutedIterator{contract: _IGatewayEVMEvents.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *IGatewayEVMEventsExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayEVMEventsExecuted) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) ParseExecuted(log types.Log) (*IGatewayEVMEventsExecuted, error) { + event := new(IGatewayEVMEventsExecuted) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IGatewayEVMEventsExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsExecutedWithERC20Iterator struct { + Event *IGatewayEVMEventsExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayEVMEventsExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayEVMEventsExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayEVMEventsExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayEVMEventsExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayEVMEventsExecutedWithERC20 represents a ExecutedWithERC20 event raised by the IGatewayEVMEvents contract. +type IGatewayEVMEventsExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*IGatewayEVMEventsExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &IGatewayEVMEventsExecutedWithERC20Iterator{contract: _IGatewayEVMEvents.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *IGatewayEVMEventsExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _IGatewayEVMEvents.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayEVMEventsExecutedWithERC20) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_IGatewayEVMEvents *IGatewayEVMEventsFilterer) ParseExecutedWithERC20(log types.Log) (*IGatewayEVMEventsExecutedWithERC20, error) { + event := new(IGatewayEVMEventsExecutedWithERC20) + if err := _IGatewayEVMEvents.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go b/pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go new file mode 100644 index 00000000..cb37e582 --- /dev/null +++ b/pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go @@ -0,0 +1,727 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IReceiverEVMEventsMetaData contains all meta data concerning the IReceiverEVMEvents contract. +var IReceiverEVMEventsMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"}]", +} + +// IReceiverEVMEventsABI is the input ABI used to generate the binding from. +// Deprecated: Use IReceiverEVMEventsMetaData.ABI instead. +var IReceiverEVMEventsABI = IReceiverEVMEventsMetaData.ABI + +// IReceiverEVMEvents is an auto generated Go binding around an Ethereum contract. +type IReceiverEVMEvents struct { + IReceiverEVMEventsCaller // Read-only binding to the contract + IReceiverEVMEventsTransactor // Write-only binding to the contract + IReceiverEVMEventsFilterer // Log filterer for contract events +} + +// IReceiverEVMEventsCaller is an auto generated read-only Go binding around an Ethereum contract. +type IReceiverEVMEventsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IReceiverEVMEventsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IReceiverEVMEventsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IReceiverEVMEventsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IReceiverEVMEventsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IReceiverEVMEventsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IReceiverEVMEventsSession struct { + Contract *IReceiverEVMEvents // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IReceiverEVMEventsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IReceiverEVMEventsCallerSession struct { + Contract *IReceiverEVMEventsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IReceiverEVMEventsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IReceiverEVMEventsTransactorSession struct { + Contract *IReceiverEVMEventsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IReceiverEVMEventsRaw is an auto generated low-level Go binding around an Ethereum contract. +type IReceiverEVMEventsRaw struct { + Contract *IReceiverEVMEvents // Generic contract binding to access the raw methods on +} + +// IReceiverEVMEventsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IReceiverEVMEventsCallerRaw struct { + Contract *IReceiverEVMEventsCaller // Generic read-only contract binding to access the raw methods on +} + +// IReceiverEVMEventsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IReceiverEVMEventsTransactorRaw struct { + Contract *IReceiverEVMEventsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIReceiverEVMEvents creates a new instance of IReceiverEVMEvents, bound to a specific deployed contract. +func NewIReceiverEVMEvents(address common.Address, backend bind.ContractBackend) (*IReceiverEVMEvents, error) { + contract, err := bindIReceiverEVMEvents(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IReceiverEVMEvents{IReceiverEVMEventsCaller: IReceiverEVMEventsCaller{contract: contract}, IReceiverEVMEventsTransactor: IReceiverEVMEventsTransactor{contract: contract}, IReceiverEVMEventsFilterer: IReceiverEVMEventsFilterer{contract: contract}}, nil +} + +// NewIReceiverEVMEventsCaller creates a new read-only instance of IReceiverEVMEvents, bound to a specific deployed contract. +func NewIReceiverEVMEventsCaller(address common.Address, caller bind.ContractCaller) (*IReceiverEVMEventsCaller, error) { + contract, err := bindIReceiverEVMEvents(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IReceiverEVMEventsCaller{contract: contract}, nil +} + +// NewIReceiverEVMEventsTransactor creates a new write-only instance of IReceiverEVMEvents, bound to a specific deployed contract. +func NewIReceiverEVMEventsTransactor(address common.Address, transactor bind.ContractTransactor) (*IReceiverEVMEventsTransactor, error) { + contract, err := bindIReceiverEVMEvents(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IReceiverEVMEventsTransactor{contract: contract}, nil +} + +// NewIReceiverEVMEventsFilterer creates a new log filterer instance of IReceiverEVMEvents, bound to a specific deployed contract. +func NewIReceiverEVMEventsFilterer(address common.Address, filterer bind.ContractFilterer) (*IReceiverEVMEventsFilterer, error) { + contract, err := bindIReceiverEVMEvents(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IReceiverEVMEventsFilterer{contract: contract}, nil +} + +// bindIReceiverEVMEvents binds a generic wrapper to an already deployed contract. +func bindIReceiverEVMEvents(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IReceiverEVMEventsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IReceiverEVMEvents *IReceiverEVMEventsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IReceiverEVMEvents.Contract.IReceiverEVMEventsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IReceiverEVMEvents *IReceiverEVMEventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IReceiverEVMEvents.Contract.IReceiverEVMEventsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IReceiverEVMEvents *IReceiverEVMEventsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IReceiverEVMEvents.Contract.IReceiverEVMEventsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IReceiverEVMEvents *IReceiverEVMEventsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IReceiverEVMEvents.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IReceiverEVMEvents *IReceiverEVMEventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IReceiverEVMEvents.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IReceiverEVMEvents *IReceiverEVMEventsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IReceiverEVMEvents.Contract.contract.Transact(opts, method, params...) +} + +// IReceiverEVMEventsReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedERC20Iterator struct { + Event *IReceiverEVMEventsReceivedERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IReceiverEVMEventsReceivedERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IReceiverEVMEventsReceivedERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IReceiverEVMEventsReceivedERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IReceiverEVMEventsReceivedERC20 represents a ReceivedERC20 event raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedERC20 struct { + Sender common.Address + Amount *big.Int + Token common.Address + Destination common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*IReceiverEVMEventsReceivedERC20Iterator, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.FilterLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return &IReceiverEVMEventsReceivedERC20Iterator{contract: _IReceiverEVMEvents.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil +} + +// WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *IReceiverEVMEventsReceivedERC20) (event.Subscription, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.WatchLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IReceiverEVMEventsReceivedERC20) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedERC20", 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 +} + +// ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) ParseReceivedERC20(log types.Log) (*IReceiverEVMEventsReceivedERC20, error) { + event := new(IReceiverEVMEventsReceivedERC20) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IReceiverEVMEventsReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedNoParamsIterator struct { + Event *IReceiverEVMEventsReceivedNoParams // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IReceiverEVMEventsReceivedNoParamsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IReceiverEVMEventsReceivedNoParamsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IReceiverEVMEventsReceivedNoParamsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IReceiverEVMEventsReceivedNoParams represents a ReceivedNoParams event raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedNoParams struct { + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*IReceiverEVMEventsReceivedNoParamsIterator, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.FilterLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return &IReceiverEVMEventsReceivedNoParamsIterator{contract: _IReceiverEVMEvents.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil +} + +// WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *IReceiverEVMEventsReceivedNoParams) (event.Subscription, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.WatchLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IReceiverEVMEventsReceivedNoParams) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedNoParams", 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 +} + +// ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) ParseReceivedNoParams(log types.Log) (*IReceiverEVMEventsReceivedNoParams, error) { + event := new(IReceiverEVMEventsReceivedNoParams) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IReceiverEVMEventsReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedNonPayableIterator struct { + Event *IReceiverEVMEventsReceivedNonPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IReceiverEVMEventsReceivedNonPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IReceiverEVMEventsReceivedNonPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IReceiverEVMEventsReceivedNonPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IReceiverEVMEventsReceivedNonPayable represents a ReceivedNonPayable event raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedNonPayable struct { + Sender common.Address + Strs []string + Nums []*big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*IReceiverEVMEventsReceivedNonPayableIterator, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.FilterLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return &IReceiverEVMEventsReceivedNonPayableIterator{contract: _IReceiverEVMEvents.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *IReceiverEVMEventsReceivedNonPayable) (event.Subscription, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.WatchLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IReceiverEVMEventsReceivedNonPayable) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedNonPayable", 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 +} + +// ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) ParseReceivedNonPayable(log types.Log) (*IReceiverEVMEventsReceivedNonPayable, error) { + event := new(IReceiverEVMEventsReceivedNonPayable) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IReceiverEVMEventsReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedPayableIterator struct { + Event *IReceiverEVMEventsReceivedPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IReceiverEVMEventsReceivedPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IReceiverEVMEventsReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IReceiverEVMEventsReceivedPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IReceiverEVMEventsReceivedPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IReceiverEVMEventsReceivedPayable represents a ReceivedPayable event raised by the IReceiverEVMEvents contract. +type IReceiverEVMEventsReceivedPayable struct { + Sender common.Address + Value *big.Int + Str string + Num *big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*IReceiverEVMEventsReceivedPayableIterator, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.FilterLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return &IReceiverEVMEventsReceivedPayableIterator{contract: _IReceiverEVMEvents.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *IReceiverEVMEventsReceivedPayable) (event.Subscription, error) { + + logs, sub, err := _IReceiverEVMEvents.contract.WatchLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IReceiverEVMEventsReceivedPayable) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedPayable", 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 +} + +// ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_IReceiverEVMEvents *IReceiverEVMEventsFilterer) ParseReceivedPayable(log types.Log) (*IReceiverEVMEventsReceivedPayable, error) { + event := new(IReceiverEVMEventsReceivedPayable) + if err := _IReceiverEVMEvents.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/base.sol/commonbase.go b/pkg/forge-std/base.sol/commonbase.go new file mode 100644 index 00000000..21558dd3 --- /dev/null +++ b/pkg/forge-std/base.sol/commonbase.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package base + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// CommonBaseMetaData contains all meta data concerning the CommonBase contract. +var CommonBaseMetaData = &bind.MetaData{ + ABI: "[]", +} + +// CommonBaseABI is the input ABI used to generate the binding from. +// Deprecated: Use CommonBaseMetaData.ABI instead. +var CommonBaseABI = CommonBaseMetaData.ABI + +// CommonBase is an auto generated Go binding around an Ethereum contract. +type CommonBase struct { + CommonBaseCaller // Read-only binding to the contract + CommonBaseTransactor // Write-only binding to the contract + CommonBaseFilterer // Log filterer for contract events +} + +// CommonBaseCaller is an auto generated read-only Go binding around an Ethereum contract. +type CommonBaseCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CommonBaseTransactor is an auto generated write-only Go binding around an Ethereum contract. +type CommonBaseTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CommonBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type CommonBaseFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// CommonBaseSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type CommonBaseSession struct { + Contract *CommonBase // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CommonBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type CommonBaseCallerSession struct { + Contract *CommonBaseCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// CommonBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type CommonBaseTransactorSession struct { + Contract *CommonBaseTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// CommonBaseRaw is an auto generated low-level Go binding around an Ethereum contract. +type CommonBaseRaw struct { + Contract *CommonBase // Generic contract binding to access the raw methods on +} + +// CommonBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type CommonBaseCallerRaw struct { + Contract *CommonBaseCaller // Generic read-only contract binding to access the raw methods on +} + +// CommonBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type CommonBaseTransactorRaw struct { + Contract *CommonBaseTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewCommonBase creates a new instance of CommonBase, bound to a specific deployed contract. +func NewCommonBase(address common.Address, backend bind.ContractBackend) (*CommonBase, error) { + contract, err := bindCommonBase(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &CommonBase{CommonBaseCaller: CommonBaseCaller{contract: contract}, CommonBaseTransactor: CommonBaseTransactor{contract: contract}, CommonBaseFilterer: CommonBaseFilterer{contract: contract}}, nil +} + +// NewCommonBaseCaller creates a new read-only instance of CommonBase, bound to a specific deployed contract. +func NewCommonBaseCaller(address common.Address, caller bind.ContractCaller) (*CommonBaseCaller, error) { + contract, err := bindCommonBase(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &CommonBaseCaller{contract: contract}, nil +} + +// NewCommonBaseTransactor creates a new write-only instance of CommonBase, bound to a specific deployed contract. +func NewCommonBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*CommonBaseTransactor, error) { + contract, err := bindCommonBase(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &CommonBaseTransactor{contract: contract}, nil +} + +// NewCommonBaseFilterer creates a new log filterer instance of CommonBase, bound to a specific deployed contract. +func NewCommonBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*CommonBaseFilterer, error) { + contract, err := bindCommonBase(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &CommonBaseFilterer{contract: contract}, nil +} + +// bindCommonBase binds a generic wrapper to an already deployed contract. +func bindCommonBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := CommonBaseMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CommonBase *CommonBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CommonBase.Contract.CommonBaseCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CommonBase *CommonBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CommonBase.Contract.CommonBaseTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CommonBase *CommonBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CommonBase.Contract.CommonBaseTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_CommonBase *CommonBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _CommonBase.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_CommonBase *CommonBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _CommonBase.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_CommonBase *CommonBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _CommonBase.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/base.sol/scriptbase.go b/pkg/forge-std/base.sol/scriptbase.go new file mode 100644 index 00000000..ef7ebeaa --- /dev/null +++ b/pkg/forge-std/base.sol/scriptbase.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package base + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ScriptBaseMetaData contains all meta data concerning the ScriptBase contract. +var ScriptBaseMetaData = &bind.MetaData{ + ABI: "[]", +} + +// ScriptBaseABI is the input ABI used to generate the binding from. +// Deprecated: Use ScriptBaseMetaData.ABI instead. +var ScriptBaseABI = ScriptBaseMetaData.ABI + +// ScriptBase is an auto generated Go binding around an Ethereum contract. +type ScriptBase struct { + ScriptBaseCaller // Read-only binding to the contract + ScriptBaseTransactor // Write-only binding to the contract + ScriptBaseFilterer // Log filterer for contract events +} + +// ScriptBaseCaller is an auto generated read-only Go binding around an Ethereum contract. +type ScriptBaseCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ScriptBaseTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ScriptBaseTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ScriptBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ScriptBaseFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ScriptBaseSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ScriptBaseSession struct { + Contract *ScriptBase // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ScriptBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ScriptBaseCallerSession struct { + Contract *ScriptBaseCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ScriptBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ScriptBaseTransactorSession struct { + Contract *ScriptBaseTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ScriptBaseRaw is an auto generated low-level Go binding around an Ethereum contract. +type ScriptBaseRaw struct { + Contract *ScriptBase // Generic contract binding to access the raw methods on +} + +// ScriptBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ScriptBaseCallerRaw struct { + Contract *ScriptBaseCaller // Generic read-only contract binding to access the raw methods on +} + +// ScriptBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ScriptBaseTransactorRaw struct { + Contract *ScriptBaseTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewScriptBase creates a new instance of ScriptBase, bound to a specific deployed contract. +func NewScriptBase(address common.Address, backend bind.ContractBackend) (*ScriptBase, error) { + contract, err := bindScriptBase(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ScriptBase{ScriptBaseCaller: ScriptBaseCaller{contract: contract}, ScriptBaseTransactor: ScriptBaseTransactor{contract: contract}, ScriptBaseFilterer: ScriptBaseFilterer{contract: contract}}, nil +} + +// NewScriptBaseCaller creates a new read-only instance of ScriptBase, bound to a specific deployed contract. +func NewScriptBaseCaller(address common.Address, caller bind.ContractCaller) (*ScriptBaseCaller, error) { + contract, err := bindScriptBase(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ScriptBaseCaller{contract: contract}, nil +} + +// NewScriptBaseTransactor creates a new write-only instance of ScriptBase, bound to a specific deployed contract. +func NewScriptBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*ScriptBaseTransactor, error) { + contract, err := bindScriptBase(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ScriptBaseTransactor{contract: contract}, nil +} + +// NewScriptBaseFilterer creates a new log filterer instance of ScriptBase, bound to a specific deployed contract. +func NewScriptBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*ScriptBaseFilterer, error) { + contract, err := bindScriptBase(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ScriptBaseFilterer{contract: contract}, nil +} + +// bindScriptBase binds a generic wrapper to an already deployed contract. +func bindScriptBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ScriptBaseMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ScriptBase *ScriptBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ScriptBase.Contract.ScriptBaseCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ScriptBase *ScriptBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ScriptBase.Contract.ScriptBaseTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ScriptBase *ScriptBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ScriptBase.Contract.ScriptBaseTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ScriptBase *ScriptBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ScriptBase.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ScriptBase *ScriptBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ScriptBase.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ScriptBase *ScriptBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ScriptBase.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/base.sol/testbase.go b/pkg/forge-std/base.sol/testbase.go new file mode 100644 index 00000000..a597895a --- /dev/null +++ b/pkg/forge-std/base.sol/testbase.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package base + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// TestBaseMetaData contains all meta data concerning the TestBase contract. +var TestBaseMetaData = &bind.MetaData{ + ABI: "[]", +} + +// TestBaseABI is the input ABI used to generate the binding from. +// Deprecated: Use TestBaseMetaData.ABI instead. +var TestBaseABI = TestBaseMetaData.ABI + +// TestBase is an auto generated Go binding around an Ethereum contract. +type TestBase struct { + TestBaseCaller // Read-only binding to the contract + TestBaseTransactor // Write-only binding to the contract + TestBaseFilterer // Log filterer for contract events +} + +// TestBaseCaller is an auto generated read-only Go binding around an Ethereum contract. +type TestBaseCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestBaseTransactor is an auto generated write-only Go binding around an Ethereum contract. +type TestBaseTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type TestBaseFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestBaseSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type TestBaseSession struct { + Contract *TestBase // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type TestBaseCallerSession struct { + Contract *TestBaseCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// TestBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type TestBaseTransactorSession struct { + Contract *TestBaseTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestBaseRaw is an auto generated low-level Go binding around an Ethereum contract. +type TestBaseRaw struct { + Contract *TestBase // Generic contract binding to access the raw methods on +} + +// TestBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type TestBaseCallerRaw struct { + Contract *TestBaseCaller // Generic read-only contract binding to access the raw methods on +} + +// TestBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type TestBaseTransactorRaw struct { + Contract *TestBaseTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewTestBase creates a new instance of TestBase, bound to a specific deployed contract. +func NewTestBase(address common.Address, backend bind.ContractBackend) (*TestBase, error) { + contract, err := bindTestBase(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &TestBase{TestBaseCaller: TestBaseCaller{contract: contract}, TestBaseTransactor: TestBaseTransactor{contract: contract}, TestBaseFilterer: TestBaseFilterer{contract: contract}}, nil +} + +// NewTestBaseCaller creates a new read-only instance of TestBase, bound to a specific deployed contract. +func NewTestBaseCaller(address common.Address, caller bind.ContractCaller) (*TestBaseCaller, error) { + contract, err := bindTestBase(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &TestBaseCaller{contract: contract}, nil +} + +// NewTestBaseTransactor creates a new write-only instance of TestBase, bound to a specific deployed contract. +func NewTestBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*TestBaseTransactor, error) { + contract, err := bindTestBase(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &TestBaseTransactor{contract: contract}, nil +} + +// NewTestBaseFilterer creates a new log filterer instance of TestBase, bound to a specific deployed contract. +func NewTestBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*TestBaseFilterer, error) { + contract, err := bindTestBase(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &TestBaseFilterer{contract: contract}, nil +} + +// bindTestBase binds a generic wrapper to an already deployed contract. +func bindTestBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := TestBaseMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestBase *TestBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestBase.Contract.TestBaseCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestBase *TestBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestBase.Contract.TestBaseTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestBase *TestBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestBase.Contract.TestBaseTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TestBase *TestBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _TestBase.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TestBase *TestBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TestBase.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TestBase *TestBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TestBase.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/console.sol/console.go b/pkg/forge-std/console.sol/console.go new file mode 100644 index 00000000..f801d776 --- /dev/null +++ b/pkg/forge-std/console.sol/console.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package console + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ConsoleMetaData contains all meta data concerning the Console contract. +var ConsoleMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220fe1ca2c4bba26bc81c4f049f87633a060d1ab61923daa843e60125aa2c1b9db164736f6c63430008070033", +} + +// ConsoleABI is the input ABI used to generate the binding from. +// Deprecated: Use ConsoleMetaData.ABI instead. +var ConsoleABI = ConsoleMetaData.ABI + +// ConsoleBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ConsoleMetaData.Bin instead. +var ConsoleBin = ConsoleMetaData.Bin + +// DeployConsole deploys a new Ethereum contract, binding an instance of Console to it. +func DeployConsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Console, error) { + parsed, err := ConsoleMetaData.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(ConsoleBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil +} + +// Console is an auto generated Go binding around an Ethereum contract. +type Console struct { + ConsoleCaller // Read-only binding to the contract + ConsoleTransactor // Write-only binding to the contract + ConsoleFilterer // Log filterer for contract events +} + +// ConsoleCaller is an auto generated read-only Go binding around an Ethereum contract. +type ConsoleCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ConsoleTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ConsoleFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ConsoleSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ConsoleSession struct { + Contract *Console // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ConsoleCallerSession struct { + Contract *ConsoleCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ConsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ConsoleTransactorSession struct { + Contract *ConsoleTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ConsoleRaw is an auto generated low-level Go binding around an Ethereum contract. +type ConsoleRaw struct { + Contract *Console // Generic contract binding to access the raw methods on +} + +// ConsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ConsoleCallerRaw struct { + Contract *ConsoleCaller // Generic read-only contract binding to access the raw methods on +} + +// ConsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ConsoleTransactorRaw struct { + Contract *ConsoleTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewConsole creates a new instance of Console, bound to a specific deployed contract. +func NewConsole(address common.Address, backend bind.ContractBackend) (*Console, error) { + contract, err := bindConsole(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Console{ConsoleCaller: ConsoleCaller{contract: contract}, ConsoleTransactor: ConsoleTransactor{contract: contract}, ConsoleFilterer: ConsoleFilterer{contract: contract}}, nil +} + +// NewConsoleCaller creates a new read-only instance of Console, bound to a specific deployed contract. +func NewConsoleCaller(address common.Address, caller bind.ContractCaller) (*ConsoleCaller, error) { + contract, err := bindConsole(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ConsoleCaller{contract: contract}, nil +} + +// NewConsoleTransactor creates a new write-only instance of Console, bound to a specific deployed contract. +func NewConsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*ConsoleTransactor, error) { + contract, err := bindConsole(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ConsoleTransactor{contract: contract}, nil +} + +// NewConsoleFilterer creates a new log filterer instance of Console, bound to a specific deployed contract. +func NewConsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*ConsoleFilterer, error) { + contract, err := bindConsole(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ConsoleFilterer{contract: contract}, nil +} + +// bindConsole binds a generic wrapper to an already deployed contract. +func bindConsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ConsoleMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Console *ConsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Console.Contract.ConsoleCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Console *ConsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Console.Contract.ConsoleTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Console *ConsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Console.Contract.ConsoleTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Console *ConsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Console.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Console *ConsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Console.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Console *ConsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Console.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/interfaces/ierc165.sol/ierc165.go b/pkg/forge-std/interfaces/ierc165.sol/ierc165.go new file mode 100644 index 00000000..a8563263 --- /dev/null +++ b/pkg/forge-std/interfaces/ierc165.sol/ierc165.go @@ -0,0 +1,212 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc165 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC165MetaData contains all meta data concerning the IERC165 contract. +var IERC165MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// IERC165ABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC165MetaData.ABI instead. +var IERC165ABI = IERC165MetaData.ABI + +// IERC165 is an auto generated Go binding around an Ethereum contract. +type IERC165 struct { + IERC165Caller // Read-only binding to the contract + IERC165Transactor // Write-only binding to the contract + IERC165Filterer // Log filterer for contract events +} + +// IERC165Caller is an auto generated read-only Go binding around an Ethereum contract. +type IERC165Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC165Transactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC165Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC165Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC165Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC165Session struct { + Contract *IERC165 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC165CallerSession struct { + Contract *IERC165Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC165TransactorSession struct { + Contract *IERC165Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC165Raw is an auto generated low-level Go binding around an Ethereum contract. +type IERC165Raw struct { + Contract *IERC165 // Generic contract binding to access the raw methods on +} + +// IERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC165CallerRaw struct { + Contract *IERC165Caller // Generic read-only contract binding to access the raw methods on +} + +// IERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC165TransactorRaw struct { + Contract *IERC165Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC165 creates a new instance of IERC165, bound to a specific deployed contract. +func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error) { + contract, err := bindIERC165(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC165{IERC165Caller: IERC165Caller{contract: contract}, IERC165Transactor: IERC165Transactor{contract: contract}, IERC165Filterer: IERC165Filterer{contract: contract}}, nil +} + +// NewIERC165Caller creates a new read-only instance of IERC165, bound to a specific deployed contract. +func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error) { + contract, err := bindIERC165(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC165Caller{contract: contract}, nil +} + +// NewIERC165Transactor creates a new write-only instance of IERC165, bound to a specific deployed contract. +func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error) { + contract, err := bindIERC165(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC165Transactor{contract: contract}, nil +} + +// NewIERC165Filterer creates a new log filterer instance of IERC165, bound to a specific deployed contract. +func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error) { + contract, err := bindIERC165(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC165Filterer{contract: contract}, nil +} + +// bindIERC165 binds a generic wrapper to an already deployed contract. +func bindIERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC165MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC165.Contract.IERC165Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC165.Contract.IERC165Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC165 *IERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC165.Contract.IERC165Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC165.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC165.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC165 *IERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC165.Contract.contract.Transact(opts, method, params...) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { + var out []interface{} + err := _IERC165.contract.Call(opts, &out, "supportsInterface", interfaceID) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC165 *IERC165Session) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceID) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceID) +} diff --git a/pkg/forge-std/interfaces/ierc20.sol/ierc20.go b/pkg/forge-std/interfaces/ierc20.sol/ierc20.go new file mode 100644 index 00000000..25687ffe --- /dev/null +++ b/pkg/forge-std/interfaces/ierc20.sol/ierc20.go @@ -0,0 +1,738 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC20MetaData contains all meta data concerning the IERC20 contract. +var IERC20MetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IERC20ABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC20MetaData.ABI instead. +var IERC20ABI = IERC20MetaData.ABI + +// IERC20 is an auto generated Go binding around an Ethereum contract. +type IERC20 struct { + IERC20Caller // Read-only binding to the contract + IERC20Transactor // Write-only binding to the contract + IERC20Filterer // Log filterer for contract events +} + +// IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type IERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC20Session struct { + Contract *IERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC20CallerSession struct { + Contract *IERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC20TransactorSession struct { + Contract *IERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type IERC20Raw struct { + Contract *IERC20 // Generic contract binding to access the raw methods on +} + +// IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC20CallerRaw struct { + Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC20TransactorRaw struct { + Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. +func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { + contract, err := bindIERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil +} + +// NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. +func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { + contract, err := bindIERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC20Caller{contract: contract}, nil +} + +// NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. +func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { + contract, err := bindIERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC20Transactor{contract: contract}, nil +} + +// NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. +func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { + contract, err := bindIERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC20Filterer{contract: contract}, nil +} + +// bindIERC20 binds a generic wrapper to an already deployed contract. +func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC20MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC20.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _IERC20.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _IERC20.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 + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) { + return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IERC20 *IERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _IERC20.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IERC20 *IERC20Session) Decimals() (uint8, error) { + return _IERC20.Contract.Decimals(&_IERC20.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IERC20 *IERC20CallerSession) Decimals() (uint8, error) { + return _IERC20.Contract.Decimals(&_IERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IERC20 *IERC20Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IERC20.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IERC20 *IERC20Session) Name() (string, error) { + return _IERC20.Contract.Name(&_IERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IERC20 *IERC20CallerSession) Name() (string, error) { + return _IERC20.Contract.Name(&_IERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IERC20 *IERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IERC20.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IERC20 *IERC20Session) Symbol() (string, error) { + return _IERC20.Contract.Symbol(&_IERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IERC20 *IERC20CallerSession) Symbol() (string, error) { + return _IERC20.Contract.Symbol(&_IERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IERC20.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { + return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { + return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, from, to, amount) +} + +// IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract. +type IERC20ApprovalIterator struct { + Event *IERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC20Approval represents a Approval event raised by the IERC20 contract. +type IERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, 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 := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, 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 := _IERC20.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: + // New log arrived, parse the event and forward to the user + event := new(IERC20Approval) + if err := _IERC20.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { + event := new(IERC20Approval) + if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract. +type IERC20TransferIterator struct { + Event *IERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC20Transfer represents a Transfer event raised by the IERC20 contract. +type IERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, 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 := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, 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 := _IERC20.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: + // New log arrived, parse the event and forward to the user + event := new(IERC20Transfer) + if err := _IERC20.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { + event := new(IERC20Transfer) + if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/interfaces/ierc721.sol/ierc721.go b/pkg/forge-std/interfaces/ierc721.sol/ierc721.go new file mode 100644 index 00000000..46e5a1bb --- /dev/null +++ b/pkg/forge-std/interfaces/ierc721.sol/ierc721.go @@ -0,0 +1,919 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc721 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC721MetaData contains all meta data concerning the IERC721 contract. +var IERC721MetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// IERC721ABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC721MetaData.ABI instead. +var IERC721ABI = IERC721MetaData.ABI + +// IERC721 is an auto generated Go binding around an Ethereum contract. +type IERC721 struct { + IERC721Caller // Read-only binding to the contract + IERC721Transactor // Write-only binding to the contract + IERC721Filterer // Log filterer for contract events +} + +// IERC721Caller is an auto generated read-only Go binding around an Ethereum contract. +type IERC721Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721Transactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC721Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC721Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC721Session struct { + Contract *IERC721 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC721CallerSession struct { + Contract *IERC721Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC721TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC721TransactorSession struct { + Contract *IERC721Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721Raw is an auto generated low-level Go binding around an Ethereum contract. +type IERC721Raw struct { + Contract *IERC721 // Generic contract binding to access the raw methods on +} + +// IERC721CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC721CallerRaw struct { + Contract *IERC721Caller // Generic read-only contract binding to access the raw methods on +} + +// IERC721TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC721TransactorRaw struct { + Contract *IERC721Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC721 creates a new instance of IERC721, bound to a specific deployed contract. +func NewIERC721(address common.Address, backend bind.ContractBackend) (*IERC721, error) { + contract, err := bindIERC721(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC721{IERC721Caller: IERC721Caller{contract: contract}, IERC721Transactor: IERC721Transactor{contract: contract}, IERC721Filterer: IERC721Filterer{contract: contract}}, nil +} + +// NewIERC721Caller creates a new read-only instance of IERC721, bound to a specific deployed contract. +func NewIERC721Caller(address common.Address, caller bind.ContractCaller) (*IERC721Caller, error) { + contract, err := bindIERC721(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC721Caller{contract: contract}, nil +} + +// NewIERC721Transactor creates a new write-only instance of IERC721, bound to a specific deployed contract. +func NewIERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC721Transactor, error) { + contract, err := bindIERC721(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC721Transactor{contract: contract}, nil +} + +// NewIERC721Filterer creates a new log filterer instance of IERC721, bound to a specific deployed contract. +func NewIERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC721Filterer, error) { + contract, err := bindIERC721(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC721Filterer{contract: contract}, nil +} + +// bindIERC721 binds a generic wrapper to an already deployed contract. +func bindIERC721(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC721MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721 *IERC721Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721.Contract.IERC721Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721 *IERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721.Contract.IERC721Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721 *IERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721.Contract.IERC721Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721 *IERC721CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721 *IERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721 *IERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721 *IERC721Caller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var out []interface{} + err := _IERC721.contract.Call(opts, &out, "balanceOf", _owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721 *IERC721Session) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721.Contract.BalanceOf(&_IERC721.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721 *IERC721CallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721.Contract.BalanceOf(&_IERC721.CallOpts, _owner) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721Caller) GetApproved(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721.contract.Call(opts, &out, "getApproved", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721Session) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721.Contract.GetApproved(&_IERC721.CallOpts, _tokenId) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721CallerSession) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721.Contract.GetApproved(&_IERC721.CallOpts, _tokenId) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721 *IERC721Caller) IsApprovedForAll(opts *bind.CallOpts, _owner common.Address, _operator common.Address) (bool, error) { + var out []interface{} + err := _IERC721.contract.Call(opts, &out, "isApprovedForAll", _owner, _operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721 *IERC721Session) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721.Contract.IsApprovedForAll(&_IERC721.CallOpts, _owner, _operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721 *IERC721CallerSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721.Contract.IsApprovedForAll(&_IERC721.CallOpts, _owner, _operator) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721Caller) OwnerOf(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721.contract.Call(opts, &out, "ownerOf", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721Session) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721.Contract.OwnerOf(&_IERC721.CallOpts, _tokenId) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721 *IERC721CallerSession) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721.Contract.OwnerOf(&_IERC721.CallOpts, _tokenId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721 *IERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { + var out []interface{} + err := _IERC721.contract.Call(opts, &out, "supportsInterface", interfaceID) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721 *IERC721Session) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721.Contract.SupportsInterface(&_IERC721.CallOpts, interfaceID) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721 *IERC721CallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721.Contract.SupportsInterface(&_IERC721.CallOpts, interfaceID) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Transactor) Approve(opts *bind.TransactOpts, _approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.contract.Transact(opts, "approve", _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Session) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.Approve(&_IERC721.TransactOpts, _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721TransactorSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.Approve(&_IERC721.TransactOpts, _approved, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.contract.Transact(opts, "safeTransferFrom", _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Session) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.SafeTransferFrom(&_IERC721.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721TransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.SafeTransferFrom(&_IERC721.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721 *IERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721.contract.Transact(opts, "safeTransferFrom0", _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721 *IERC721Session) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721.Contract.SafeTransferFrom0(&_IERC721.TransactOpts, _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721 *IERC721TransactorSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721.Contract.SafeTransferFrom0(&_IERC721.TransactOpts, _from, _to, _tokenId, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721 *IERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, _operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721.contract.Transact(opts, "setApprovalForAll", _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721 *IERC721Session) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721.Contract.SetApprovalForAll(&_IERC721.TransactOpts, _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721 *IERC721TransactorSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721.Contract.SetApprovalForAll(&_IERC721.TransactOpts, _operator, _approved) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Transactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.contract.Transact(opts, "transferFrom", _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721Session) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.TransferFrom(&_IERC721.TransactOpts, _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721 *IERC721TransactorSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721.Contract.TransferFrom(&_IERC721.TransactOpts, _from, _to, _tokenId) +} + +// IERC721ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721 contract. +type IERC721ApprovalIterator struct { + Event *IERC721Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721Approval represents a Approval event raised by the IERC721 contract. +type IERC721Approval struct { + Owner common.Address + Approved common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (*IERC721ApprovalIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721.contract.FilterLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721ApprovalIterator{contract: _IERC721.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721Approval, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721.contract.WatchLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721Approval) + if err := _IERC721.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) ParseApproval(log types.Log) (*IERC721Approval, error) { + event := new(IERC721Approval) + if err := _IERC721.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721ApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721 contract. +type IERC721ApprovalForAllIterator struct { + Event *IERC721ApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721ApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721ApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721ApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721ApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721ApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721ApprovalForAll represents a ApprovalForAll event raised by the IERC721 contract. +type IERC721ApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721 *IERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*IERC721ApprovalForAllIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721.contract.FilterLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return &IERC721ApprovalForAllIterator{contract: _IERC721.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721 *IERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721ApprovalForAll, _owner []common.Address, _operator []common.Address) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721.contract.WatchLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721ApprovalForAll) + if err := _IERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721 *IERC721Filterer) ParseApprovalForAll(log types.Log) (*IERC721ApprovalForAll, error) { + event := new(IERC721ApprovalForAll) + if err := _IERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721 contract. +type IERC721TransferIterator struct { + Event *IERC721Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721Transfer represents a Transfer event raised by the IERC721 contract. +type IERC721Transfer struct { + From common.Address + To common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (*IERC721TransferIterator, error) { + + var _fromRule []interface{} + for _, _fromItem := range _from { + _fromRule = append(_fromRule, _fromItem) + } + var _toRule []interface{} + for _, _toItem := range _to { + _toRule = append(_toRule, _toItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721TransferIterator{contract: _IERC721.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721Transfer, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (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) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721Transfer) + if err := _IERC721.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721 *IERC721Filterer) ParseTransfer(log types.Log) (*IERC721Transfer, error) { + event := new(IERC721Transfer) + if err := _IERC721.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/interfaces/ierc721.sol/ierc721enumerable.go b/pkg/forge-std/interfaces/ierc721.sol/ierc721enumerable.go new file mode 100644 index 00000000..ad90f8b5 --- /dev/null +++ b/pkg/forge-std/interfaces/ierc721.sol/ierc721enumerable.go @@ -0,0 +1,1012 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc721 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC721EnumerableMetaData contains all meta data concerning the IERC721Enumerable contract. +var IERC721EnumerableMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_index\",\"type\":\"uint256\"}],\"name\":\"tokenByIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_index\",\"type\":\"uint256\"}],\"name\":\"tokenOfOwnerByIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// IERC721EnumerableABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC721EnumerableMetaData.ABI instead. +var IERC721EnumerableABI = IERC721EnumerableMetaData.ABI + +// IERC721Enumerable is an auto generated Go binding around an Ethereum contract. +type IERC721Enumerable struct { + IERC721EnumerableCaller // Read-only binding to the contract + IERC721EnumerableTransactor // Write-only binding to the contract + IERC721EnumerableFilterer // Log filterer for contract events +} + +// IERC721EnumerableCaller is an auto generated read-only Go binding around an Ethereum contract. +type IERC721EnumerableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721EnumerableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC721EnumerableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721EnumerableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC721EnumerableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721EnumerableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC721EnumerableSession struct { + Contract *IERC721Enumerable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721EnumerableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC721EnumerableCallerSession struct { + Contract *IERC721EnumerableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC721EnumerableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC721EnumerableTransactorSession struct { + Contract *IERC721EnumerableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721EnumerableRaw is an auto generated low-level Go binding around an Ethereum contract. +type IERC721EnumerableRaw struct { + Contract *IERC721Enumerable // Generic contract binding to access the raw methods on +} + +// IERC721EnumerableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC721EnumerableCallerRaw struct { + Contract *IERC721EnumerableCaller // Generic read-only contract binding to access the raw methods on +} + +// IERC721EnumerableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC721EnumerableTransactorRaw struct { + Contract *IERC721EnumerableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC721Enumerable creates a new instance of IERC721Enumerable, bound to a specific deployed contract. +func NewIERC721Enumerable(address common.Address, backend bind.ContractBackend) (*IERC721Enumerable, error) { + contract, err := bindIERC721Enumerable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC721Enumerable{IERC721EnumerableCaller: IERC721EnumerableCaller{contract: contract}, IERC721EnumerableTransactor: IERC721EnumerableTransactor{contract: contract}, IERC721EnumerableFilterer: IERC721EnumerableFilterer{contract: contract}}, nil +} + +// NewIERC721EnumerableCaller creates a new read-only instance of IERC721Enumerable, bound to a specific deployed contract. +func NewIERC721EnumerableCaller(address common.Address, caller bind.ContractCaller) (*IERC721EnumerableCaller, error) { + contract, err := bindIERC721Enumerable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC721EnumerableCaller{contract: contract}, nil +} + +// NewIERC721EnumerableTransactor creates a new write-only instance of IERC721Enumerable, bound to a specific deployed contract. +func NewIERC721EnumerableTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721EnumerableTransactor, error) { + contract, err := bindIERC721Enumerable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC721EnumerableTransactor{contract: contract}, nil +} + +// NewIERC721EnumerableFilterer creates a new log filterer instance of IERC721Enumerable, bound to a specific deployed contract. +func NewIERC721EnumerableFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721EnumerableFilterer, error) { + contract, err := bindIERC721Enumerable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC721EnumerableFilterer{contract: contract}, nil +} + +// bindIERC721Enumerable binds a generic wrapper to an already deployed contract. +func bindIERC721Enumerable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC721EnumerableMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721Enumerable *IERC721EnumerableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721Enumerable.Contract.IERC721EnumerableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721Enumerable *IERC721EnumerableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.IERC721EnumerableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721Enumerable *IERC721EnumerableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.IERC721EnumerableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721Enumerable *IERC721EnumerableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721Enumerable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721Enumerable *IERC721EnumerableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "balanceOf", _owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721Enumerable.Contract.BalanceOf(&_IERC721Enumerable.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721Enumerable.Contract.BalanceOf(&_IERC721Enumerable.CallOpts, _owner) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableCaller) GetApproved(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "getApproved", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableSession) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721Enumerable.Contract.GetApproved(&_IERC721Enumerable.CallOpts, _tokenId) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721Enumerable.Contract.GetApproved(&_IERC721Enumerable.CallOpts, _tokenId) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableCaller) IsApprovedForAll(opts *bind.CallOpts, _owner common.Address, _operator common.Address) (bool, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "isApprovedForAll", _owner, _operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721Enumerable.Contract.IsApprovedForAll(&_IERC721Enumerable.CallOpts, _owner, _operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721Enumerable.Contract.IsApprovedForAll(&_IERC721Enumerable.CallOpts, _owner, _operator) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableCaller) OwnerOf(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "ownerOf", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableSession) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721Enumerable.Contract.OwnerOf(&_IERC721Enumerable.CallOpts, _tokenId) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721Enumerable.Contract.OwnerOf(&_IERC721Enumerable.CallOpts, _tokenId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "supportsInterface", interfaceID) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721Enumerable.Contract.SupportsInterface(&_IERC721Enumerable.CallOpts, interfaceID) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721Enumerable.Contract.SupportsInterface(&_IERC721Enumerable.CallOpts, interfaceID) +} + +// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7. +// +// Solidity: function tokenByIndex(uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCaller) TokenByIndex(opts *bind.CallOpts, _index *big.Int) (*big.Int, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "tokenByIndex", _index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7. +// +// Solidity: function tokenByIndex(uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableSession) TokenByIndex(_index *big.Int) (*big.Int, error) { + return _IERC721Enumerable.Contract.TokenByIndex(&_IERC721Enumerable.CallOpts, _index) +} + +// TokenByIndex is a free data retrieval call binding the contract method 0x4f6ccce7. +// +// Solidity: function tokenByIndex(uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenByIndex(_index *big.Int) (*big.Int, error) { + return _IERC721Enumerable.Contract.TokenByIndex(&_IERC721Enumerable.CallOpts, _index) +} + +// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59. +// +// Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCaller) TokenOfOwnerByIndex(opts *bind.CallOpts, _owner common.Address, _index *big.Int) (*big.Int, error) { + var out []interface{} + err := _IERC721Enumerable.contract.Call(opts, &out, "tokenOfOwnerByIndex", _owner, _index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59. +// +// Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableSession) TokenOfOwnerByIndex(_owner common.Address, _index *big.Int) (*big.Int, error) { + return _IERC721Enumerable.Contract.TokenOfOwnerByIndex(&_IERC721Enumerable.CallOpts, _owner, _index) +} + +// TokenOfOwnerByIndex is a free data retrieval call binding the contract method 0x2f745c59. +// +// Solidity: function tokenOfOwnerByIndex(address _owner, uint256 _index) view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) TokenOfOwnerByIndex(_owner common.Address, _index *big.Int) (*big.Int, error) { + return _IERC721Enumerable.Contract.TokenOfOwnerByIndex(&_IERC721Enumerable.CallOpts, _owner, _index) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IERC721Enumerable.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableSession) TotalSupply() (*big.Int, error) { + return _IERC721Enumerable.Contract.TotalSupply(&_IERC721Enumerable.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IERC721Enumerable *IERC721EnumerableCallerSession) TotalSupply() (*big.Int, error) { + return _IERC721Enumerable.Contract.TotalSupply(&_IERC721Enumerable.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactor) Approve(opts *bind.TransactOpts, _approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.contract.Transact(opts, "approve", _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.Approve(&_IERC721Enumerable.TransactOpts, _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactorSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.Approve(&_IERC721Enumerable.TransactOpts, _approved, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.contract.Transact(opts, "safeTransferFrom", _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SafeTransferFrom(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SafeTransferFrom(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactor) SafeTransferFrom0(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Enumerable.contract.Transact(opts, "safeTransferFrom0", _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Enumerable *IERC721EnumerableSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SafeTransferFrom0(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SafeTransferFrom0(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Enumerable *IERC721EnumerableTransactor) SetApprovalForAll(opts *bind.TransactOpts, _operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Enumerable.contract.Transact(opts, "setApprovalForAll", _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Enumerable *IERC721EnumerableSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SetApprovalForAll(&_IERC721Enumerable.TransactOpts, _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Enumerable *IERC721EnumerableTransactorSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.SetApprovalForAll(&_IERC721Enumerable.TransactOpts, _operator, _approved) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.contract.Transact(opts, "transferFrom", _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.TransferFrom(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Enumerable *IERC721EnumerableTransactorSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Enumerable.Contract.TransferFrom(&_IERC721Enumerable.TransactOpts, _from, _to, _tokenId) +} + +// IERC721EnumerableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721Enumerable contract. +type IERC721EnumerableApprovalIterator struct { + Event *IERC721EnumerableApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721EnumerableApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721EnumerableApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721EnumerableApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721EnumerableApproval represents a Approval event raised by the IERC721Enumerable contract. +type IERC721EnumerableApproval struct { + Owner common.Address + Approved common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (*IERC721EnumerableApprovalIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721EnumerableApprovalIterator{contract: _IERC721Enumerable.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApproval, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721EnumerableApproval) + if err := _IERC721Enumerable.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApproval(log types.Log) (*IERC721EnumerableApproval, error) { + event := new(IERC721EnumerableApproval) + if err := _IERC721Enumerable.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721EnumerableApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721Enumerable contract. +type IERC721EnumerableApprovalForAllIterator struct { + Event *IERC721EnumerableApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721EnumerableApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721EnumerableApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721EnumerableApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721EnumerableApprovalForAll represents a ApprovalForAll event raised by the IERC721Enumerable contract. +type IERC721EnumerableApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*IERC721EnumerableApprovalForAllIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return &IERC721EnumerableApprovalForAllIterator{contract: _IERC721Enumerable.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableApprovalForAll, _owner []common.Address, _operator []common.Address) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721EnumerableApprovalForAll) + if err := _IERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseApprovalForAll(log types.Log) (*IERC721EnumerableApprovalForAll, error) { + event := new(IERC721EnumerableApprovalForAll) + if err := _IERC721Enumerable.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721EnumerableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721Enumerable contract. +type IERC721EnumerableTransferIterator struct { + Event *IERC721EnumerableTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721EnumerableTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721EnumerableTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721EnumerableTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721EnumerableTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721EnumerableTransfer represents a Transfer event raised by the IERC721Enumerable contract. +type IERC721EnumerableTransfer struct { + From common.Address + To common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (*IERC721EnumerableTransferIterator, error) { + + var _fromRule []interface{} + for _, _fromItem := range _from { + _fromRule = append(_fromRule, _fromItem) + } + var _toRule []interface{} + for _, _toItem := range _to { + _toRule = append(_toRule, _toItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Enumerable.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721EnumerableTransferIterator{contract: _IERC721Enumerable.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721EnumerableTransfer, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (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) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Enumerable.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721EnumerableTransfer) + if err := _IERC721Enumerable.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Enumerable *IERC721EnumerableFilterer) ParseTransfer(log types.Log) (*IERC721EnumerableTransfer, error) { + event := new(IERC721EnumerableTransfer) + if err := _IERC721Enumerable.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/interfaces/ierc721.sol/ierc721metadata.go b/pkg/forge-std/interfaces/ierc721.sol/ierc721metadata.go new file mode 100644 index 00000000..f0ebe2de --- /dev/null +++ b/pkg/forge-std/interfaces/ierc721.sol/ierc721metadata.go @@ -0,0 +1,1012 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc721 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC721MetadataMetaData contains all meta data concerning the IERC721Metadata contract. +var IERC721MetadataMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"_symbol\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// IERC721MetadataABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC721MetadataMetaData.ABI instead. +var IERC721MetadataABI = IERC721MetadataMetaData.ABI + +// IERC721Metadata is an auto generated Go binding around an Ethereum contract. +type IERC721Metadata struct { + IERC721MetadataCaller // Read-only binding to the contract + IERC721MetadataTransactor // Write-only binding to the contract + IERC721MetadataFilterer // Log filterer for contract events +} + +// IERC721MetadataCaller is an auto generated read-only Go binding around an Ethereum contract. +type IERC721MetadataCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721MetadataTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC721MetadataTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721MetadataFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC721MetadataFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721MetadataSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC721MetadataSession struct { + Contract *IERC721Metadata // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721MetadataCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC721MetadataCallerSession struct { + Contract *IERC721MetadataCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC721MetadataTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC721MetadataTransactorSession struct { + Contract *IERC721MetadataTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721MetadataRaw is an auto generated low-level Go binding around an Ethereum contract. +type IERC721MetadataRaw struct { + Contract *IERC721Metadata // Generic contract binding to access the raw methods on +} + +// IERC721MetadataCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC721MetadataCallerRaw struct { + Contract *IERC721MetadataCaller // Generic read-only contract binding to access the raw methods on +} + +// IERC721MetadataTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC721MetadataTransactorRaw struct { + Contract *IERC721MetadataTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC721Metadata creates a new instance of IERC721Metadata, bound to a specific deployed contract. +func NewIERC721Metadata(address common.Address, backend bind.ContractBackend) (*IERC721Metadata, error) { + contract, err := bindIERC721Metadata(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC721Metadata{IERC721MetadataCaller: IERC721MetadataCaller{contract: contract}, IERC721MetadataTransactor: IERC721MetadataTransactor{contract: contract}, IERC721MetadataFilterer: IERC721MetadataFilterer{contract: contract}}, nil +} + +// NewIERC721MetadataCaller creates a new read-only instance of IERC721Metadata, bound to a specific deployed contract. +func NewIERC721MetadataCaller(address common.Address, caller bind.ContractCaller) (*IERC721MetadataCaller, error) { + contract, err := bindIERC721Metadata(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC721MetadataCaller{contract: contract}, nil +} + +// NewIERC721MetadataTransactor creates a new write-only instance of IERC721Metadata, bound to a specific deployed contract. +func NewIERC721MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721MetadataTransactor, error) { + contract, err := bindIERC721Metadata(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC721MetadataTransactor{contract: contract}, nil +} + +// NewIERC721MetadataFilterer creates a new log filterer instance of IERC721Metadata, bound to a specific deployed contract. +func NewIERC721MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721MetadataFilterer, error) { + contract, err := bindIERC721Metadata(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC721MetadataFilterer{contract: contract}, nil +} + +// bindIERC721Metadata binds a generic wrapper to an already deployed contract. +func bindIERC721Metadata(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC721MetadataMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721Metadata *IERC721MetadataRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721Metadata.Contract.IERC721MetadataCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721Metadata *IERC721MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721Metadata.Contract.IERC721MetadataTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721Metadata *IERC721MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721Metadata.Contract.IERC721MetadataTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721Metadata *IERC721MetadataCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721Metadata.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721Metadata.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721Metadata *IERC721MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721Metadata.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Metadata *IERC721MetadataCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "balanceOf", _owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Metadata *IERC721MetadataSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721Metadata.Contract.BalanceOf(&_IERC721Metadata.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256) +func (_IERC721Metadata *IERC721MetadataCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _IERC721Metadata.Contract.BalanceOf(&_IERC721Metadata.CallOpts, _owner) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataCaller) GetApproved(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "getApproved", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataSession) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721Metadata.Contract.GetApproved(&_IERC721Metadata.CallOpts, _tokenId) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataCallerSession) GetApproved(_tokenId *big.Int) (common.Address, error) { + return _IERC721Metadata.Contract.GetApproved(&_IERC721Metadata.CallOpts, _tokenId) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Metadata *IERC721MetadataCaller) IsApprovedForAll(opts *bind.CallOpts, _owner common.Address, _operator common.Address) (bool, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "isApprovedForAll", _owner, _operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Metadata *IERC721MetadataSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721Metadata.Contract.IsApprovedForAll(&_IERC721Metadata.CallOpts, _owner, _operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool) +func (_IERC721Metadata *IERC721MetadataCallerSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) { + return _IERC721Metadata.Contract.IsApprovedForAll(&_IERC721Metadata.CallOpts, _owner, _operator) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string _name) +func (_IERC721Metadata *IERC721MetadataCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string _name) +func (_IERC721Metadata *IERC721MetadataSession) Name() (string, error) { + return _IERC721Metadata.Contract.Name(&_IERC721Metadata.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string _name) +func (_IERC721Metadata *IERC721MetadataCallerSession) Name() (string, error) { + return _IERC721Metadata.Contract.Name(&_IERC721Metadata.CallOpts) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataCaller) OwnerOf(opts *bind.CallOpts, _tokenId *big.Int) (common.Address, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "ownerOf", _tokenId) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataSession) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721Metadata.Contract.OwnerOf(&_IERC721Metadata.CallOpts, _tokenId) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 _tokenId) view returns(address) +func (_IERC721Metadata *IERC721MetadataCallerSession) OwnerOf(_tokenId *big.Int) (common.Address, error) { + return _IERC721Metadata.Contract.OwnerOf(&_IERC721Metadata.CallOpts, _tokenId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Metadata *IERC721MetadataCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "supportsInterface", interfaceID) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Metadata *IERC721MetadataSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721Metadata.Contract.SupportsInterface(&_IERC721Metadata.CallOpts, interfaceID) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceID) view returns(bool) +func (_IERC721Metadata *IERC721MetadataCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) { + return _IERC721Metadata.Contract.SupportsInterface(&_IERC721Metadata.CallOpts, interfaceID) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string _symbol) +func (_IERC721Metadata *IERC721MetadataCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string _symbol) +func (_IERC721Metadata *IERC721MetadataSession) Symbol() (string, error) { + return _IERC721Metadata.Contract.Symbol(&_IERC721Metadata.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string _symbol) +func (_IERC721Metadata *IERC721MetadataCallerSession) Symbol() (string, error) { + return _IERC721Metadata.Contract.Symbol(&_IERC721Metadata.CallOpts) +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 _tokenId) view returns(string) +func (_IERC721Metadata *IERC721MetadataCaller) TokenURI(opts *bind.CallOpts, _tokenId *big.Int) (string, error) { + var out []interface{} + err := _IERC721Metadata.contract.Call(opts, &out, "tokenURI", _tokenId) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 _tokenId) view returns(string) +func (_IERC721Metadata *IERC721MetadataSession) TokenURI(_tokenId *big.Int) (string, error) { + return _IERC721Metadata.Contract.TokenURI(&_IERC721Metadata.CallOpts, _tokenId) +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 _tokenId) view returns(string) +func (_IERC721Metadata *IERC721MetadataCallerSession) TokenURI(_tokenId *big.Int) (string, error) { + return _IERC721Metadata.Contract.TokenURI(&_IERC721Metadata.CallOpts, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactor) Approve(opts *bind.TransactOpts, _approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.contract.Transact(opts, "approve", _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.Approve(&_IERC721Metadata.TransactOpts, _approved, _tokenId) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _approved, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactorSession) Approve(_approved common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.Approve(&_IERC721Metadata.TransactOpts, _approved, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.contract.Transact(opts, "safeTransferFrom", _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SafeTransferFrom(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SafeTransferFrom(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactor) SafeTransferFrom0(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Metadata.contract.Transact(opts, "safeTransferFrom0", _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Metadata *IERC721MetadataSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SafeTransferFrom0(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes data) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactorSession) SafeTransferFrom0(_from common.Address, _to common.Address, _tokenId *big.Int, data []byte) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SafeTransferFrom0(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Metadata *IERC721MetadataTransactor) SetApprovalForAll(opts *bind.TransactOpts, _operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Metadata.contract.Transact(opts, "setApprovalForAll", _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Metadata *IERC721MetadataSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SetApprovalForAll(&_IERC721Metadata.TransactOpts, _operator, _approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address _operator, bool _approved) returns() +func (_IERC721Metadata *IERC721MetadataTransactorSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) { + return _IERC721Metadata.Contract.SetApprovalForAll(&_IERC721Metadata.TransactOpts, _operator, _approved) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.contract.Transact(opts, "transferFrom", _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.TransferFrom(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _tokenId) payable returns() +func (_IERC721Metadata *IERC721MetadataTransactorSession) TransferFrom(_from common.Address, _to common.Address, _tokenId *big.Int) (*types.Transaction, error) { + return _IERC721Metadata.Contract.TransferFrom(&_IERC721Metadata.TransactOpts, _from, _to, _tokenId) +} + +// IERC721MetadataApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC721Metadata contract. +type IERC721MetadataApprovalIterator struct { + Event *IERC721MetadataApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721MetadataApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721MetadataApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721MetadataApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721MetadataApproval represents a Approval event raised by the IERC721Metadata contract. +type IERC721MetadataApproval struct { + Owner common.Address + Approved common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (*IERC721MetadataApprovalIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721MetadataApprovalIterator{contract: _IERC721Metadata.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApproval, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721MetadataApproval) + if err := _IERC721Metadata.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) ParseApproval(log types.Log) (*IERC721MetadataApproval, error) { + event := new(IERC721MetadataApproval) + if err := _IERC721Metadata.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721MetadataApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the IERC721Metadata contract. +type IERC721MetadataApprovalForAllIterator struct { + Event *IERC721MetadataApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721MetadataApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721MetadataApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721MetadataApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721MetadataApprovalForAll represents a ApprovalForAll event raised by the IERC721Metadata contract. +type IERC721MetadataApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Metadata *IERC721MetadataFilterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*IERC721MetadataApprovalForAllIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return &IERC721MetadataApprovalForAllIterator{contract: _IERC721Metadata.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Metadata *IERC721MetadataFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *IERC721MetadataApprovalForAll, _owner []common.Address, _operator []common.Address) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721MetadataApprovalForAll) + if err := _IERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_IERC721Metadata *IERC721MetadataFilterer) ParseApprovalForAll(log types.Log) (*IERC721MetadataApprovalForAll, error) { + event := new(IERC721MetadataApprovalForAll) + if err := _IERC721Metadata.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IERC721MetadataTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC721Metadata contract. +type IERC721MetadataTransferIterator struct { + Event *IERC721MetadataTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC721MetadataTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC721MetadataTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC721MetadataTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC721MetadataTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC721MetadataTransfer represents a Transfer event raised by the IERC721Metadata contract. +type IERC721MetadataTransfer struct { + From common.Address + To common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (*IERC721MetadataTransferIterator, error) { + + var _fromRule []interface{} + for _, _fromItem := range _from { + _fromRule = append(_fromRule, _fromItem) + } + var _toRule []interface{} + for _, _toItem := range _to { + _toRule = append(_toRule, _toItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Metadata.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &IERC721MetadataTransferIterator{contract: _IERC721Metadata.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC721MetadataTransfer, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (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) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _IERC721Metadata.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC721MetadataTransfer) + if err := _IERC721Metadata.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_IERC721Metadata *IERC721MetadataFilterer) ParseTransfer(log types.Log) (*IERC721MetadataTransfer, error) { + event := new(IERC721MetadataTransfer) + if err := _IERC721Metadata.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/interfaces/ierc721.sol/ierc721tokenreceiver.go b/pkg/forge-std/interfaces/ierc721.sol/ierc721tokenreceiver.go new file mode 100644 index 00000000..37f55072 --- /dev/null +++ b/pkg/forge-std/interfaces/ierc721.sol/ierc721tokenreceiver.go @@ -0,0 +1,202 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ierc721 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IERC721TokenReceiverMetaData contains all meta data concerning the IERC721TokenReceiver contract. +var IERC721TokenReceiverMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"onERC721Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IERC721TokenReceiverABI is the input ABI used to generate the binding from. +// Deprecated: Use IERC721TokenReceiverMetaData.ABI instead. +var IERC721TokenReceiverABI = IERC721TokenReceiverMetaData.ABI + +// IERC721TokenReceiver is an auto generated Go binding around an Ethereum contract. +type IERC721TokenReceiver struct { + IERC721TokenReceiverCaller // Read-only binding to the contract + IERC721TokenReceiverTransactor // Write-only binding to the contract + IERC721TokenReceiverFilterer // Log filterer for contract events +} + +// IERC721TokenReceiverCaller is an auto generated read-only Go binding around an Ethereum contract. +type IERC721TokenReceiverCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721TokenReceiverTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC721TokenReceiverTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721TokenReceiverFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC721TokenReceiverFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IERC721TokenReceiverSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IERC721TokenReceiverSession struct { + Contract *IERC721TokenReceiver // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721TokenReceiverCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IERC721TokenReceiverCallerSession struct { + Contract *IERC721TokenReceiverCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IERC721TokenReceiverTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IERC721TokenReceiverTransactorSession struct { + Contract *IERC721TokenReceiverTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IERC721TokenReceiverRaw is an auto generated low-level Go binding around an Ethereum contract. +type IERC721TokenReceiverRaw struct { + Contract *IERC721TokenReceiver // Generic contract binding to access the raw methods on +} + +// IERC721TokenReceiverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC721TokenReceiverCallerRaw struct { + Contract *IERC721TokenReceiverCaller // Generic read-only contract binding to access the raw methods on +} + +// IERC721TokenReceiverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC721TokenReceiverTransactorRaw struct { + Contract *IERC721TokenReceiverTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIERC721TokenReceiver creates a new instance of IERC721TokenReceiver, bound to a specific deployed contract. +func NewIERC721TokenReceiver(address common.Address, backend bind.ContractBackend) (*IERC721TokenReceiver, error) { + contract, err := bindIERC721TokenReceiver(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IERC721TokenReceiver{IERC721TokenReceiverCaller: IERC721TokenReceiverCaller{contract: contract}, IERC721TokenReceiverTransactor: IERC721TokenReceiverTransactor{contract: contract}, IERC721TokenReceiverFilterer: IERC721TokenReceiverFilterer{contract: contract}}, nil +} + +// NewIERC721TokenReceiverCaller creates a new read-only instance of IERC721TokenReceiver, bound to a specific deployed contract. +func NewIERC721TokenReceiverCaller(address common.Address, caller bind.ContractCaller) (*IERC721TokenReceiverCaller, error) { + contract, err := bindIERC721TokenReceiver(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IERC721TokenReceiverCaller{contract: contract}, nil +} + +// NewIERC721TokenReceiverTransactor creates a new write-only instance of IERC721TokenReceiver, bound to a specific deployed contract. +func NewIERC721TokenReceiverTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC721TokenReceiverTransactor, error) { + contract, err := bindIERC721TokenReceiver(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IERC721TokenReceiverTransactor{contract: contract}, nil +} + +// NewIERC721TokenReceiverFilterer creates a new log filterer instance of IERC721TokenReceiver, bound to a specific deployed contract. +func NewIERC721TokenReceiverFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC721TokenReceiverFilterer, error) { + contract, err := bindIERC721TokenReceiver(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IERC721TokenReceiverFilterer{contract: contract}, nil +} + +// bindIERC721TokenReceiver binds a generic wrapper to an already deployed contract. +func bindIERC721TokenReceiver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IERC721TokenReceiverMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721TokenReceiver *IERC721TokenReceiverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721TokenReceiver.Contract.IERC721TokenReceiverCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721TokenReceiver *IERC721TokenReceiverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.IERC721TokenReceiverTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721TokenReceiver *IERC721TokenReceiverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.IERC721TokenReceiverTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IERC721TokenReceiver *IERC721TokenReceiverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IERC721TokenReceiver.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IERC721TokenReceiver *IERC721TokenReceiverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IERC721TokenReceiver *IERC721TokenReceiverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.contract.Transact(opts, method, params...) +} + +// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02. +// +// Solidity: function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) returns(bytes4) +func (_IERC721TokenReceiver *IERC721TokenReceiverTransactor) OnERC721Received(opts *bind.TransactOpts, _operator common.Address, _from common.Address, _tokenId *big.Int, _data []byte) (*types.Transaction, error) { + return _IERC721TokenReceiver.contract.Transact(opts, "onERC721Received", _operator, _from, _tokenId, _data) +} + +// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02. +// +// Solidity: function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) returns(bytes4) +func (_IERC721TokenReceiver *IERC721TokenReceiverSession) OnERC721Received(_operator common.Address, _from common.Address, _tokenId *big.Int, _data []byte) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.OnERC721Received(&_IERC721TokenReceiver.TransactOpts, _operator, _from, _tokenId, _data) +} + +// OnERC721Received is a paid mutator transaction binding the contract method 0x150b7a02. +// +// Solidity: function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes _data) returns(bytes4) +func (_IERC721TokenReceiver *IERC721TokenReceiverTransactorSession) OnERC721Received(_operator common.Address, _from common.Address, _tokenId *big.Int, _data []byte) (*types.Transaction, error) { + return _IERC721TokenReceiver.Contract.OnERC721Received(&_IERC721TokenReceiver.TransactOpts, _operator, _from, _tokenId, _data) +} diff --git a/pkg/forge-std/interfaces/imulticall3.sol/imulticall3.go b/pkg/forge-std/interfaces/imulticall3.sol/imulticall3.go new file mode 100644 index 00000000..fef9956a --- /dev/null +++ b/pkg/forge-std/interfaces/imulticall3.sol/imulticall3.go @@ -0,0 +1,644 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package imulticall3 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IMulticall3Call is an auto generated low-level Go binding around an user-defined struct. +type IMulticall3Call struct { + Target common.Address + CallData []byte +} + +// IMulticall3Call3 is an auto generated low-level Go binding around an user-defined struct. +type IMulticall3Call3 struct { + Target common.Address + AllowFailure bool + CallData []byte +} + +// IMulticall3Call3Value is an auto generated low-level Go binding around an user-defined struct. +type IMulticall3Call3Value struct { + Target common.Address + AllowFailure bool + Value *big.Int + CallData []byte +} + +// IMulticall3Result is an auto generated low-level Go binding around an user-defined struct. +type IMulticall3Result struct { + Success bool + ReturnData []byte +} + +// IMulticall3MetaData contains all meta data concerning the IMulticall3 contract. +var IMulticall3MetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes[]\",\"name\":\"returnData\",\"type\":\"bytes[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowFailure\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call3[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate3\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"allowFailure\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call3Value[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"aggregate3Value\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"blockAndAggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBasefee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"basefee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"getBlockHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"chainid\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockCoinbase\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"coinbase\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockDifficulty\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"difficulty\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockGasLimit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"gaslimit\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCurrentBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"getEthBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastBlockHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"requireSuccess\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"tryAggregate\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"requireSuccess\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Call[]\",\"name\":\"calls\",\"type\":\"tuple[]\"}],\"name\":\"tryBlockAndAggregate\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"internalType\":\"structIMulticall3.Result[]\",\"name\":\"returnData\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"}]", +} + +// IMulticall3ABI is the input ABI used to generate the binding from. +// Deprecated: Use IMulticall3MetaData.ABI instead. +var IMulticall3ABI = IMulticall3MetaData.ABI + +// IMulticall3 is an auto generated Go binding around an Ethereum contract. +type IMulticall3 struct { + IMulticall3Caller // Read-only binding to the contract + IMulticall3Transactor // Write-only binding to the contract + IMulticall3Filterer // Log filterer for contract events +} + +// IMulticall3Caller is an auto generated read-only Go binding around an Ethereum contract. +type IMulticall3Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IMulticall3Transactor is an auto generated write-only Go binding around an Ethereum contract. +type IMulticall3Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IMulticall3Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IMulticall3Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IMulticall3Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IMulticall3Session struct { + Contract *IMulticall3 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IMulticall3CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IMulticall3CallerSession struct { + Contract *IMulticall3Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IMulticall3TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IMulticall3TransactorSession struct { + Contract *IMulticall3Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IMulticall3Raw is an auto generated low-level Go binding around an Ethereum contract. +type IMulticall3Raw struct { + Contract *IMulticall3 // Generic contract binding to access the raw methods on +} + +// IMulticall3CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IMulticall3CallerRaw struct { + Contract *IMulticall3Caller // Generic read-only contract binding to access the raw methods on +} + +// IMulticall3TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IMulticall3TransactorRaw struct { + Contract *IMulticall3Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewIMulticall3 creates a new instance of IMulticall3, bound to a specific deployed contract. +func NewIMulticall3(address common.Address, backend bind.ContractBackend) (*IMulticall3, error) { + contract, err := bindIMulticall3(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IMulticall3{IMulticall3Caller: IMulticall3Caller{contract: contract}, IMulticall3Transactor: IMulticall3Transactor{contract: contract}, IMulticall3Filterer: IMulticall3Filterer{contract: contract}}, nil +} + +// NewIMulticall3Caller creates a new read-only instance of IMulticall3, bound to a specific deployed contract. +func NewIMulticall3Caller(address common.Address, caller bind.ContractCaller) (*IMulticall3Caller, error) { + contract, err := bindIMulticall3(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IMulticall3Caller{contract: contract}, nil +} + +// NewIMulticall3Transactor creates a new write-only instance of IMulticall3, bound to a specific deployed contract. +func NewIMulticall3Transactor(address common.Address, transactor bind.ContractTransactor) (*IMulticall3Transactor, error) { + contract, err := bindIMulticall3(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IMulticall3Transactor{contract: contract}, nil +} + +// NewIMulticall3Filterer creates a new log filterer instance of IMulticall3, bound to a specific deployed contract. +func NewIMulticall3Filterer(address common.Address, filterer bind.ContractFilterer) (*IMulticall3Filterer, error) { + contract, err := bindIMulticall3(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IMulticall3Filterer{contract: contract}, nil +} + +// bindIMulticall3 binds a generic wrapper to an already deployed contract. +func bindIMulticall3(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IMulticall3MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IMulticall3 *IMulticall3Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IMulticall3.Contract.IMulticall3Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IMulticall3 *IMulticall3Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IMulticall3.Contract.IMulticall3Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IMulticall3 *IMulticall3Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IMulticall3.Contract.IMulticall3Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IMulticall3 *IMulticall3CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IMulticall3.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IMulticall3 *IMulticall3TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IMulticall3.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IMulticall3 *IMulticall3TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IMulticall3.Contract.contract.Transact(opts, method, params...) +} + +// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696. +// +// Solidity: function getBasefee() view returns(uint256 basefee) +func (_IMulticall3 *IMulticall3Caller) GetBasefee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getBasefee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696. +// +// Solidity: function getBasefee() view returns(uint256 basefee) +func (_IMulticall3 *IMulticall3Session) GetBasefee() (*big.Int, error) { + return _IMulticall3.Contract.GetBasefee(&_IMulticall3.CallOpts) +} + +// GetBasefee is a free data retrieval call binding the contract method 0x3e64a696. +// +// Solidity: function getBasefee() view returns(uint256 basefee) +func (_IMulticall3 *IMulticall3CallerSession) GetBasefee() (*big.Int, error) { + return _IMulticall3.Contract.GetBasefee(&_IMulticall3.CallOpts) +} + +// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e. +// +// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3Caller) GetBlockHash(opts *bind.CallOpts, blockNumber *big.Int) ([32]byte, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getBlockHash", blockNumber) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e. +// +// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3Session) GetBlockHash(blockNumber *big.Int) ([32]byte, error) { + return _IMulticall3.Contract.GetBlockHash(&_IMulticall3.CallOpts, blockNumber) +} + +// GetBlockHash is a free data retrieval call binding the contract method 0xee82ac5e. +// +// Solidity: function getBlockHash(uint256 blockNumber) view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3CallerSession) GetBlockHash(blockNumber *big.Int) ([32]byte, error) { + return _IMulticall3.Contract.GetBlockHash(&_IMulticall3.CallOpts, blockNumber) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 blockNumber) +func (_IMulticall3 *IMulticall3Caller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getBlockNumber") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 blockNumber) +func (_IMulticall3 *IMulticall3Session) GetBlockNumber() (*big.Int, error) { + return _IMulticall3.Contract.GetBlockNumber(&_IMulticall3.CallOpts) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 blockNumber) +func (_IMulticall3 *IMulticall3CallerSession) GetBlockNumber() (*big.Int, error) { + return _IMulticall3.Contract.GetBlockNumber(&_IMulticall3.CallOpts) +} + +// GetChainId is a free data retrieval call binding the contract method 0x3408e470. +// +// Solidity: function getChainId() view returns(uint256 chainid) +func (_IMulticall3 *IMulticall3Caller) GetChainId(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getChainId") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetChainId is a free data retrieval call binding the contract method 0x3408e470. +// +// Solidity: function getChainId() view returns(uint256 chainid) +func (_IMulticall3 *IMulticall3Session) GetChainId() (*big.Int, error) { + return _IMulticall3.Contract.GetChainId(&_IMulticall3.CallOpts) +} + +// GetChainId is a free data retrieval call binding the contract method 0x3408e470. +// +// Solidity: function getChainId() view returns(uint256 chainid) +func (_IMulticall3 *IMulticall3CallerSession) GetChainId() (*big.Int, error) { + return _IMulticall3.Contract.GetChainId(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e. +// +// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase) +func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockCoinbase(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockCoinbase") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e. +// +// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase) +func (_IMulticall3 *IMulticall3Session) GetCurrentBlockCoinbase() (common.Address, error) { + return _IMulticall3.Contract.GetCurrentBlockCoinbase(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockCoinbase is a free data retrieval call binding the contract method 0xa8b0574e. +// +// Solidity: function getCurrentBlockCoinbase() view returns(address coinbase) +func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockCoinbase() (common.Address, error) { + return _IMulticall3.Contract.GetCurrentBlockCoinbase(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d. +// +// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty) +func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockDifficulty(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockDifficulty") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d. +// +// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty) +func (_IMulticall3 *IMulticall3Session) GetCurrentBlockDifficulty() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockDifficulty(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockDifficulty is a free data retrieval call binding the contract method 0x72425d9d. +// +// Solidity: function getCurrentBlockDifficulty() view returns(uint256 difficulty) +func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockDifficulty() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockDifficulty(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8. +// +// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit) +func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockGasLimit(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockGasLimit") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8. +// +// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit) +func (_IMulticall3 *IMulticall3Session) GetCurrentBlockGasLimit() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockGasLimit(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockGasLimit is a free data retrieval call binding the contract method 0x86d516e8. +// +// Solidity: function getCurrentBlockGasLimit() view returns(uint256 gaslimit) +func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockGasLimit() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockGasLimit(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d. +// +// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp) +func (_IMulticall3 *IMulticall3Caller) GetCurrentBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getCurrentBlockTimestamp") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d. +// +// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp) +func (_IMulticall3 *IMulticall3Session) GetCurrentBlockTimestamp() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockTimestamp(&_IMulticall3.CallOpts) +} + +// GetCurrentBlockTimestamp is a free data retrieval call binding the contract method 0x0f28c97d. +// +// Solidity: function getCurrentBlockTimestamp() view returns(uint256 timestamp) +func (_IMulticall3 *IMulticall3CallerSession) GetCurrentBlockTimestamp() (*big.Int, error) { + return _IMulticall3.Contract.GetCurrentBlockTimestamp(&_IMulticall3.CallOpts) +} + +// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc. +// +// Solidity: function getEthBalance(address addr) view returns(uint256 balance) +func (_IMulticall3 *IMulticall3Caller) GetEthBalance(opts *bind.CallOpts, addr common.Address) (*big.Int, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getEthBalance", addr) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc. +// +// Solidity: function getEthBalance(address addr) view returns(uint256 balance) +func (_IMulticall3 *IMulticall3Session) GetEthBalance(addr common.Address) (*big.Int, error) { + return _IMulticall3.Contract.GetEthBalance(&_IMulticall3.CallOpts, addr) +} + +// GetEthBalance is a free data retrieval call binding the contract method 0x4d2301cc. +// +// Solidity: function getEthBalance(address addr) view returns(uint256 balance) +func (_IMulticall3 *IMulticall3CallerSession) GetEthBalance(addr common.Address) (*big.Int, error) { + return _IMulticall3.Contract.GetEthBalance(&_IMulticall3.CallOpts, addr) +} + +// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e. +// +// Solidity: function getLastBlockHash() view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3Caller) GetLastBlockHash(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _IMulticall3.contract.Call(opts, &out, "getLastBlockHash") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e. +// +// Solidity: function getLastBlockHash() view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3Session) GetLastBlockHash() ([32]byte, error) { + return _IMulticall3.Contract.GetLastBlockHash(&_IMulticall3.CallOpts) +} + +// GetLastBlockHash is a free data retrieval call binding the contract method 0x27e86d6e. +// +// Solidity: function getLastBlockHash() view returns(bytes32 blockHash) +func (_IMulticall3 *IMulticall3CallerSession) GetLastBlockHash() ([32]byte, error) { + return _IMulticall3.Contract.GetLastBlockHash(&_IMulticall3.CallOpts) +} + +// Aggregate is a paid mutator transaction binding the contract method 0x252dba42. +// +// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData) +func (_IMulticall3 *IMulticall3Transactor) Aggregate(opts *bind.TransactOpts, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "aggregate", calls) +} + +// Aggregate is a paid mutator transaction binding the contract method 0x252dba42. +// +// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData) +func (_IMulticall3 *IMulticall3Session) Aggregate(calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate(&_IMulticall3.TransactOpts, calls) +} + +// Aggregate is a paid mutator transaction binding the contract method 0x252dba42. +// +// Solidity: function aggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) Aggregate(calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate(&_IMulticall3.TransactOpts, calls) +} + +// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb. +// +// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Transactor) Aggregate3(opts *bind.TransactOpts, calls []IMulticall3Call3) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "aggregate3", calls) +} + +// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb. +// +// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Session) Aggregate3(calls []IMulticall3Call3) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate3(&_IMulticall3.TransactOpts, calls) +} + +// Aggregate3 is a paid mutator transaction binding the contract method 0x82ad56cb. +// +// Solidity: function aggregate3((address,bool,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) Aggregate3(calls []IMulticall3Call3) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate3(&_IMulticall3.TransactOpts, calls) +} + +// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71. +// +// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Transactor) Aggregate3Value(opts *bind.TransactOpts, calls []IMulticall3Call3Value) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "aggregate3Value", calls) +} + +// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71. +// +// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Session) Aggregate3Value(calls []IMulticall3Call3Value) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate3Value(&_IMulticall3.TransactOpts, calls) +} + +// Aggregate3Value is a paid mutator transaction binding the contract method 0x174dea71. +// +// Solidity: function aggregate3Value((address,bool,uint256,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) Aggregate3Value(calls []IMulticall3Call3Value) (*types.Transaction, error) { + return _IMulticall3.Contract.Aggregate3Value(&_IMulticall3.TransactOpts, calls) +} + +// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9. +// +// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Transactor) BlockAndAggregate(opts *bind.TransactOpts, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "blockAndAggregate", calls) +} + +// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9. +// +// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Session) BlockAndAggregate(calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.BlockAndAggregate(&_IMulticall3.TransactOpts, calls) +} + +// BlockAndAggregate is a paid mutator transaction binding the contract method 0xc3077fa9. +// +// Solidity: function blockAndAggregate((address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) BlockAndAggregate(calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.BlockAndAggregate(&_IMulticall3.TransactOpts, calls) +} + +// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7. +// +// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Transactor) TryAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "tryAggregate", requireSuccess, calls) +} + +// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7. +// +// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Session) TryAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.TryAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls) +} + +// TryAggregate is a paid mutator transaction binding the contract method 0xbce38bd7. +// +// Solidity: function tryAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns((bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) TryAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.TryAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls) +} + +// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9. +// +// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Transactor) TryBlockAndAggregate(opts *bind.TransactOpts, requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.contract.Transact(opts, "tryBlockAndAggregate", requireSuccess, calls) +} + +// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9. +// +// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3Session) TryBlockAndAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.TryBlockAndAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls) +} + +// TryBlockAndAggregate is a paid mutator transaction binding the contract method 0x399542e9. +// +// Solidity: function tryBlockAndAggregate(bool requireSuccess, (address,bytes)[] calls) payable returns(uint256 blockNumber, bytes32 blockHash, (bool,bytes)[] returnData) +func (_IMulticall3 *IMulticall3TransactorSession) TryBlockAndAggregate(requireSuccess bool, calls []IMulticall3Call) (*types.Transaction, error) { + return _IMulticall3.Contract.TryBlockAndAggregate(&_IMulticall3.TransactOpts, requireSuccess, calls) +} diff --git a/pkg/forge-std/mocks/mockerc20.sol/mockerc20.go b/pkg/forge-std/mocks/mockerc20.sol/mockerc20.go new file mode 100644 index 00000000..2961e7b7 --- /dev/null +++ b/pkg/forge-std/mocks/mockerc20.sol/mockerc20.go @@ -0,0 +1,864 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package mockerc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// MockERC20MetaData contains all meta data concerning the MockERC20 contract. +var MockERC20MetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// MockERC20ABI is the input ABI used to generate the binding from. +// Deprecated: Use MockERC20MetaData.ABI instead. +var MockERC20ABI = MockERC20MetaData.ABI + +// MockERC20Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use MockERC20MetaData.Bin instead. +var MockERC20Bin = MockERC20MetaData.Bin + +// DeployMockERC20 deploys a new Ethereum contract, binding an instance of MockERC20 to it. +func DeployMockERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MockERC20, error) { + parsed, err := MockERC20MetaData.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(MockERC20Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &MockERC20{MockERC20Caller: MockERC20Caller{contract: contract}, MockERC20Transactor: MockERC20Transactor{contract: contract}, MockERC20Filterer: MockERC20Filterer{contract: contract}}, nil +} + +// MockERC20 is an auto generated Go binding around an Ethereum contract. +type MockERC20 struct { + MockERC20Caller // Read-only binding to the contract + MockERC20Transactor // Write-only binding to the contract + MockERC20Filterer // Log filterer for contract events +} + +// MockERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type MockERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type MockERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MockERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MockERC20Session struct { + Contract *MockERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MockERC20CallerSession struct { + Contract *MockERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MockERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MockERC20TransactorSession struct { + Contract *MockERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type MockERC20Raw struct { + Contract *MockERC20 // Generic contract binding to access the raw methods on +} + +// MockERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MockERC20CallerRaw struct { + Contract *MockERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// MockERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MockERC20TransactorRaw struct { + Contract *MockERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewMockERC20 creates a new instance of MockERC20, bound to a specific deployed contract. +func NewMockERC20(address common.Address, backend bind.ContractBackend) (*MockERC20, error) { + contract, err := bindMockERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &MockERC20{MockERC20Caller: MockERC20Caller{contract: contract}, MockERC20Transactor: MockERC20Transactor{contract: contract}, MockERC20Filterer: MockERC20Filterer{contract: contract}}, nil +} + +// NewMockERC20Caller creates a new read-only instance of MockERC20, bound to a specific deployed contract. +func NewMockERC20Caller(address common.Address, caller bind.ContractCaller) (*MockERC20Caller, error) { + contract, err := bindMockERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MockERC20Caller{contract: contract}, nil +} + +// NewMockERC20Transactor creates a new write-only instance of MockERC20, bound to a specific deployed contract. +func NewMockERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*MockERC20Transactor, error) { + contract, err := bindMockERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MockERC20Transactor{contract: contract}, nil +} + +// NewMockERC20Filterer creates a new log filterer instance of MockERC20, bound to a specific deployed contract. +func NewMockERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*MockERC20Filterer, error) { + contract, err := bindMockERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MockERC20Filterer{contract: contract}, nil +} + +// bindMockERC20 binds a generic wrapper to an already deployed contract. +func bindMockERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MockERC20MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_MockERC20 *MockERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MockERC20.Contract.MockERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_MockERC20 *MockERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MockERC20.Contract.MockERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MockERC20 *MockERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MockERC20.Contract.MockERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_MockERC20 *MockERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MockERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_MockERC20 *MockERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MockERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MockERC20 *MockERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MockERC20.Contract.contract.Transact(opts, method, params...) +} + +// DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. +// +// Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) +func (_MockERC20 *MockERC20Caller) DOMAINSEPARATOR(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "DOMAIN_SEPARATOR") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. +// +// Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) +func (_MockERC20 *MockERC20Session) DOMAINSEPARATOR() ([32]byte, error) { + return _MockERC20.Contract.DOMAINSEPARATOR(&_MockERC20.CallOpts) +} + +// DOMAINSEPARATOR is a free data retrieval call binding the contract method 0x3644e515. +// +// Solidity: function DOMAIN_SEPARATOR() view returns(bytes32) +func (_MockERC20 *MockERC20CallerSession) DOMAINSEPARATOR() ([32]byte, error) { + return _MockERC20.Contract.DOMAINSEPARATOR(&_MockERC20.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_MockERC20 *MockERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _MockERC20.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_MockERC20 *MockERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _MockERC20.Contract.Allowance(&_MockERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_MockERC20 *MockERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _MockERC20.Contract.Allowance(&_MockERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC20 *MockERC20Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "balanceOf", owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC20 *MockERC20Session) BalanceOf(owner common.Address) (*big.Int, error) { + return _MockERC20.Contract.BalanceOf(&_MockERC20.CallOpts, owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC20 *MockERC20CallerSession) BalanceOf(owner common.Address) (*big.Int, error) { + return _MockERC20.Contract.BalanceOf(&_MockERC20.CallOpts, owner) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_MockERC20 *MockERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_MockERC20 *MockERC20Session) Decimals() (uint8, error) { + return _MockERC20.Contract.Decimals(&_MockERC20.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_MockERC20 *MockERC20CallerSession) Decimals() (uint8, error) { + return _MockERC20.Contract.Decimals(&_MockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC20 *MockERC20Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC20 *MockERC20Session) Name() (string, error) { + return _MockERC20.Contract.Name(&_MockERC20.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC20 *MockERC20CallerSession) Name() (string, error) { + return _MockERC20.Contract.Name(&_MockERC20.CallOpts) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_MockERC20 *MockERC20Caller) Nonces(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "nonces", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_MockERC20 *MockERC20Session) Nonces(arg0 common.Address) (*big.Int, error) { + return _MockERC20.Contract.Nonces(&_MockERC20.CallOpts, arg0) +} + +// Nonces is a free data retrieval call binding the contract method 0x7ecebe00. +// +// Solidity: function nonces(address ) view returns(uint256) +func (_MockERC20 *MockERC20CallerSession) Nonces(arg0 common.Address) (*big.Int, error) { + return _MockERC20.Contract.Nonces(&_MockERC20.CallOpts, arg0) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC20 *MockERC20Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _MockERC20.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC20 *MockERC20Session) Symbol() (string, error) { + return _MockERC20.Contract.Symbol(&_MockERC20.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC20 *MockERC20CallerSession) Symbol() (string, error) { + return _MockERC20.Contract.Symbol(&_MockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_MockERC20 *MockERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _MockERC20.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_MockERC20 *MockERC20Session) TotalSupply() (*big.Int, error) { + return _MockERC20.Contract.TotalSupply(&_MockERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_MockERC20 *MockERC20CallerSession) TotalSupply() (*big.Int, error) { + return _MockERC20.Contract.TotalSupply(&_MockERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.Approve(&_MockERC20.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.Approve(&_MockERC20.TransactOpts, spender, amount) +} + +// Initialize is a paid mutator transaction binding the contract method 0x1624f6c6. +// +// Solidity: function initialize(string name_, string symbol_, uint8 decimals_) returns() +func (_MockERC20 *MockERC20Transactor) Initialize(opts *bind.TransactOpts, name_ string, symbol_ string, decimals_ uint8) (*types.Transaction, error) { + return _MockERC20.contract.Transact(opts, "initialize", name_, symbol_, decimals_) +} + +// Initialize is a paid mutator transaction binding the contract method 0x1624f6c6. +// +// Solidity: function initialize(string name_, string symbol_, uint8 decimals_) returns() +func (_MockERC20 *MockERC20Session) Initialize(name_ string, symbol_ string, decimals_ uint8) (*types.Transaction, error) { + return _MockERC20.Contract.Initialize(&_MockERC20.TransactOpts, name_, symbol_, decimals_) +} + +// Initialize is a paid mutator transaction binding the contract method 0x1624f6c6. +// +// Solidity: function initialize(string name_, string symbol_, uint8 decimals_) returns() +func (_MockERC20 *MockERC20TransactorSession) Initialize(name_ string, symbol_ string, decimals_ uint8) (*types.Transaction, error) { + return _MockERC20.Contract.Initialize(&_MockERC20.TransactOpts, name_, symbol_, decimals_) +} + +// Permit is a paid mutator transaction binding the contract method 0xd505accf. +// +// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() +func (_MockERC20 *MockERC20Transactor) Permit(opts *bind.TransactOpts, owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { + return _MockERC20.contract.Transact(opts, "permit", owner, spender, value, deadline, v, r, s) +} + +// Permit is a paid mutator transaction binding the contract method 0xd505accf. +// +// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() +func (_MockERC20 *MockERC20Session) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { + return _MockERC20.Contract.Permit(&_MockERC20.TransactOpts, owner, spender, value, deadline, v, r, s) +} + +// Permit is a paid mutator transaction binding the contract method 0xd505accf. +// +// Solidity: function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) returns() +func (_MockERC20 *MockERC20TransactorSession) Permit(owner common.Address, spender common.Address, value *big.Int, deadline *big.Int, v uint8, r [32]byte, s [32]byte) (*types.Transaction, error) { + return _MockERC20.Contract.Permit(&_MockERC20.TransactOpts, owner, spender, value, deadline, v, r, s) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Session) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.Transfer(&_MockERC20.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20TransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.Transfer(&_MockERC20.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20Session) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.TransferFrom(&_MockERC20.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_MockERC20 *MockERC20TransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _MockERC20.Contract.TransferFrom(&_MockERC20.TransactOpts, from, to, amount) +} + +// MockERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the MockERC20 contract. +type MockERC20ApprovalIterator struct { + Event *MockERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockERC20Approval represents a Approval event raised by the MockERC20 contract. +type MockERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_MockERC20 *MockERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*MockERC20ApprovalIterator, 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 := _MockERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &MockERC20ApprovalIterator{contract: _MockERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_MockERC20 *MockERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *MockERC20Approval, 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 := _MockERC20.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: + // New log arrived, parse the event and forward to the user + event := new(MockERC20Approval) + if err := _MockERC20.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_MockERC20 *MockERC20Filterer) ParseApproval(log types.Log) (*MockERC20Approval, error) { + event := new(MockERC20Approval) + if err := _MockERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the MockERC20 contract. +type MockERC20TransferIterator struct { + Event *MockERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockERC20Transfer represents a Transfer event raised by the MockERC20 contract. +type MockERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_MockERC20 *MockERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*MockERC20TransferIterator, 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 := _MockERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &MockERC20TransferIterator{contract: _MockERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_MockERC20 *MockERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *MockERC20Transfer, 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 := _MockERC20.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: + // New log arrived, parse the event and forward to the user + event := new(MockERC20Transfer) + if err := _MockERC20.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_MockERC20 *MockERC20Filterer) ParseTransfer(log types.Log) (*MockERC20Transfer, error) { + event := new(MockERC20Transfer) + if err := _MockERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/mocks/mockerc721.sol/mockerc721.go b/pkg/forge-std/mocks/mockerc721.sol/mockerc721.go new file mode 100644 index 00000000..641085b4 --- /dev/null +++ b/pkg/forge-std/mocks/mockerc721.sol/mockerc721.go @@ -0,0 +1,1055 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package mockerc721 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// MockERC721MetaData contains all meta data concerning the MockERC721 contract. +var MockERC721MetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_approved\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_tokenId\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"getApproved\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"ownerOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"tokenURI\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", + Bin: "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", +} + +// MockERC721ABI is the input ABI used to generate the binding from. +// Deprecated: Use MockERC721MetaData.ABI instead. +var MockERC721ABI = MockERC721MetaData.ABI + +// MockERC721Bin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use MockERC721MetaData.Bin instead. +var MockERC721Bin = MockERC721MetaData.Bin + +// DeployMockERC721 deploys a new Ethereum contract, binding an instance of MockERC721 to it. +func DeployMockERC721(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MockERC721, error) { + parsed, err := MockERC721MetaData.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(MockERC721Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &MockERC721{MockERC721Caller: MockERC721Caller{contract: contract}, MockERC721Transactor: MockERC721Transactor{contract: contract}, MockERC721Filterer: MockERC721Filterer{contract: contract}}, nil +} + +// MockERC721 is an auto generated Go binding around an Ethereum contract. +type MockERC721 struct { + MockERC721Caller // Read-only binding to the contract + MockERC721Transactor // Write-only binding to the contract + MockERC721Filterer // Log filterer for contract events +} + +// MockERC721Caller is an auto generated read-only Go binding around an Ethereum contract. +type MockERC721Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC721Transactor is an auto generated write-only Go binding around an Ethereum contract. +type MockERC721Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC721Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type MockERC721Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// MockERC721Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type MockERC721Session struct { + Contract *MockERC721 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockERC721CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type MockERC721CallerSession struct { + Contract *MockERC721Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// MockERC721TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type MockERC721TransactorSession struct { + Contract *MockERC721Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// MockERC721Raw is an auto generated low-level Go binding around an Ethereum contract. +type MockERC721Raw struct { + Contract *MockERC721 // Generic contract binding to access the raw methods on +} + +// MockERC721CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type MockERC721CallerRaw struct { + Contract *MockERC721Caller // Generic read-only contract binding to access the raw methods on +} + +// MockERC721TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type MockERC721TransactorRaw struct { + Contract *MockERC721Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewMockERC721 creates a new instance of MockERC721, bound to a specific deployed contract. +func NewMockERC721(address common.Address, backend bind.ContractBackend) (*MockERC721, error) { + contract, err := bindMockERC721(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &MockERC721{MockERC721Caller: MockERC721Caller{contract: contract}, MockERC721Transactor: MockERC721Transactor{contract: contract}, MockERC721Filterer: MockERC721Filterer{contract: contract}}, nil +} + +// NewMockERC721Caller creates a new read-only instance of MockERC721, bound to a specific deployed contract. +func NewMockERC721Caller(address common.Address, caller bind.ContractCaller) (*MockERC721Caller, error) { + contract, err := bindMockERC721(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &MockERC721Caller{contract: contract}, nil +} + +// NewMockERC721Transactor creates a new write-only instance of MockERC721, bound to a specific deployed contract. +func NewMockERC721Transactor(address common.Address, transactor bind.ContractTransactor) (*MockERC721Transactor, error) { + contract, err := bindMockERC721(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &MockERC721Transactor{contract: contract}, nil +} + +// NewMockERC721Filterer creates a new log filterer instance of MockERC721, bound to a specific deployed contract. +func NewMockERC721Filterer(address common.Address, filterer bind.ContractFilterer) (*MockERC721Filterer, error) { + contract, err := bindMockERC721(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &MockERC721Filterer{contract: contract}, nil +} + +// bindMockERC721 binds a generic wrapper to an already deployed contract. +func bindMockERC721(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := MockERC721MetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_MockERC721 *MockERC721Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MockERC721.Contract.MockERC721Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_MockERC721 *MockERC721Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MockERC721.Contract.MockERC721Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MockERC721 *MockERC721Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MockERC721.Contract.MockERC721Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_MockERC721 *MockERC721CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _MockERC721.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_MockERC721 *MockERC721TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _MockERC721.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_MockERC721 *MockERC721TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _MockERC721.Contract.contract.Transact(opts, method, params...) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC721 *MockERC721Caller) BalanceOf(opts *bind.CallOpts, owner common.Address) (*big.Int, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "balanceOf", owner) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC721 *MockERC721Session) BalanceOf(owner common.Address) (*big.Int, error) { + return _MockERC721.Contract.BalanceOf(&_MockERC721.CallOpts, owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address owner) view returns(uint256) +func (_MockERC721 *MockERC721CallerSession) BalanceOf(owner common.Address) (*big.Int, error) { + return _MockERC721.Contract.BalanceOf(&_MockERC721.CallOpts, owner) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 id) view returns(address) +func (_MockERC721 *MockERC721Caller) GetApproved(opts *bind.CallOpts, id *big.Int) (common.Address, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "getApproved", id) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 id) view returns(address) +func (_MockERC721 *MockERC721Session) GetApproved(id *big.Int) (common.Address, error) { + return _MockERC721.Contract.GetApproved(&_MockERC721.CallOpts, id) +} + +// GetApproved is a free data retrieval call binding the contract method 0x081812fc. +// +// Solidity: function getApproved(uint256 id) view returns(address) +func (_MockERC721 *MockERC721CallerSession) GetApproved(id *big.Int) (common.Address, error) { + return _MockERC721.Contract.GetApproved(&_MockERC721.CallOpts, id) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_MockERC721 *MockERC721Caller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "isApprovedForAll", owner, operator) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_MockERC721 *MockERC721Session) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _MockERC721.Contract.IsApprovedForAll(&_MockERC721.CallOpts, owner, operator) +} + +// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5. +// +// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool) +func (_MockERC721 *MockERC721CallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) { + return _MockERC721.Contract.IsApprovedForAll(&_MockERC721.CallOpts, owner, operator) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC721 *MockERC721Caller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC721 *MockERC721Session) Name() (string, error) { + return _MockERC721.Contract.Name(&_MockERC721.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_MockERC721 *MockERC721CallerSession) Name() (string, error) { + return _MockERC721.Contract.Name(&_MockERC721.CallOpts) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 id) view returns(address owner) +func (_MockERC721 *MockERC721Caller) OwnerOf(opts *bind.CallOpts, id *big.Int) (common.Address, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "ownerOf", id) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 id) view returns(address owner) +func (_MockERC721 *MockERC721Session) OwnerOf(id *big.Int) (common.Address, error) { + return _MockERC721.Contract.OwnerOf(&_MockERC721.CallOpts, id) +} + +// OwnerOf is a free data retrieval call binding the contract method 0x6352211e. +// +// Solidity: function ownerOf(uint256 id) view returns(address owner) +func (_MockERC721 *MockERC721CallerSession) OwnerOf(id *big.Int) (common.Address, error) { + return _MockERC721.Contract.OwnerOf(&_MockERC721.CallOpts, id) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_MockERC721 *MockERC721Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "supportsInterface", interfaceId) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_MockERC721 *MockERC721Session) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _MockERC721.Contract.SupportsInterface(&_MockERC721.CallOpts, interfaceId) +} + +// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. +// +// Solidity: function supportsInterface(bytes4 interfaceId) view returns(bool) +func (_MockERC721 *MockERC721CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { + return _MockERC721.Contract.SupportsInterface(&_MockERC721.CallOpts, interfaceId) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC721 *MockERC721Caller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC721 *MockERC721Session) Symbol() (string, error) { + return _MockERC721.Contract.Symbol(&_MockERC721.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_MockERC721 *MockERC721CallerSession) Symbol() (string, error) { + return _MockERC721.Contract.Symbol(&_MockERC721.CallOpts) +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 id) view returns(string) +func (_MockERC721 *MockERC721Caller) TokenURI(opts *bind.CallOpts, id *big.Int) (string, error) { + var out []interface{} + err := _MockERC721.contract.Call(opts, &out, "tokenURI", id) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 id) view returns(string) +func (_MockERC721 *MockERC721Session) TokenURI(id *big.Int) (string, error) { + return _MockERC721.Contract.TokenURI(&_MockERC721.CallOpts, id) +} + +// TokenURI is a free data retrieval call binding the contract method 0xc87b56dd. +// +// Solidity: function tokenURI(uint256 id) view returns(string) +func (_MockERC721 *MockERC721CallerSession) TokenURI(id *big.Int) (string, error) { + return _MockERC721.Contract.TokenURI(&_MockERC721.CallOpts, id) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 id) payable returns() +func (_MockERC721 *MockERC721Transactor) Approve(opts *bind.TransactOpts, spender common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "approve", spender, id) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 id) payable returns() +func (_MockERC721 *MockERC721Session) Approve(spender common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.Approve(&_MockERC721.TransactOpts, spender, id) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 id) payable returns() +func (_MockERC721 *MockERC721TransactorSession) Approve(spender common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.Approve(&_MockERC721.TransactOpts, spender, id) +} + +// Initialize is a paid mutator transaction binding the contract method 0x4cd88b76. +// +// Solidity: function initialize(string name_, string symbol_) returns() +func (_MockERC721 *MockERC721Transactor) Initialize(opts *bind.TransactOpts, name_ string, symbol_ string) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "initialize", name_, symbol_) +} + +// Initialize is a paid mutator transaction binding the contract method 0x4cd88b76. +// +// Solidity: function initialize(string name_, string symbol_) returns() +func (_MockERC721 *MockERC721Session) Initialize(name_ string, symbol_ string) (*types.Transaction, error) { + return _MockERC721.Contract.Initialize(&_MockERC721.TransactOpts, name_, symbol_) +} + +// Initialize is a paid mutator transaction binding the contract method 0x4cd88b76. +// +// Solidity: function initialize(string name_, string symbol_) returns() +func (_MockERC721 *MockERC721TransactorSession) Initialize(name_ string, symbol_ string) (*types.Transaction, error) { + return _MockERC721.Contract.Initialize(&_MockERC721.TransactOpts, name_, symbol_) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721Transactor) SafeTransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "safeTransferFrom", from, to, id) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721Session) SafeTransferFrom(from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.SafeTransferFrom(&_MockERC721.TransactOpts, from, to, id) +} + +// SafeTransferFrom is a paid mutator transaction binding the contract method 0x42842e0e. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721TransactorSession) SafeTransferFrom(from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.SafeTransferFrom(&_MockERC721.TransactOpts, from, to, id) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, bytes data) payable returns() +func (_MockERC721 *MockERC721Transactor) SafeTransferFrom0(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int, data []byte) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "safeTransferFrom0", from, to, id, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, bytes data) payable returns() +func (_MockERC721 *MockERC721Session) SafeTransferFrom0(from common.Address, to common.Address, id *big.Int, data []byte) (*types.Transaction, error) { + return _MockERC721.Contract.SafeTransferFrom0(&_MockERC721.TransactOpts, from, to, id, data) +} + +// SafeTransferFrom0 is a paid mutator transaction binding the contract method 0xb88d4fde. +// +// Solidity: function safeTransferFrom(address from, address to, uint256 id, bytes data) payable returns() +func (_MockERC721 *MockERC721TransactorSession) SafeTransferFrom0(from common.Address, to common.Address, id *big.Int, data []byte) (*types.Transaction, error) { + return _MockERC721.Contract.SafeTransferFrom0(&_MockERC721.TransactOpts, from, to, id, data) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_MockERC721 *MockERC721Transactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "setApprovalForAll", operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_MockERC721 *MockERC721Session) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _MockERC721.Contract.SetApprovalForAll(&_MockERC721.TransactOpts, operator, approved) +} + +// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465. +// +// Solidity: function setApprovalForAll(address operator, bool approved) returns() +func (_MockERC721 *MockERC721TransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) { + return _MockERC721.Contract.SetApprovalForAll(&_MockERC721.TransactOpts, operator, approved) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.contract.Transact(opts, "transferFrom", from, to, id) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721Session) TransferFrom(from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.TransferFrom(&_MockERC721.TransactOpts, from, to, id) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 id) payable returns() +func (_MockERC721 *MockERC721TransactorSession) TransferFrom(from common.Address, to common.Address, id *big.Int) (*types.Transaction, error) { + return _MockERC721.Contract.TransferFrom(&_MockERC721.TransactOpts, from, to, id) +} + +// MockERC721ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the MockERC721 contract. +type MockERC721ApprovalIterator struct { + Event *MockERC721Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockERC721ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockERC721Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockERC721Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockERC721ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockERC721ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockERC721Approval represents a Approval event raised by the MockERC721 contract. +type MockERC721Approval struct { + Owner common.Address + Approved common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) FilterApproval(opts *bind.FilterOpts, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (*MockERC721ApprovalIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _MockERC721.contract.FilterLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &MockERC721ApprovalIterator{contract: _MockERC721.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *MockERC721Approval, _owner []common.Address, _approved []common.Address, _tokenId []*big.Int) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _approvedRule []interface{} + for _, _approvedItem := range _approved { + _approvedRule = append(_approvedRule, _approvedItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _MockERC721.contract.WatchLogs(opts, "Approval", _ownerRule, _approvedRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockERC721Approval) + if err := _MockERC721.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) ParseApproval(log types.Log) (*MockERC721Approval, error) { + event := new(MockERC721Approval) + if err := _MockERC721.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockERC721ApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the MockERC721 contract. +type MockERC721ApprovalForAllIterator struct { + Event *MockERC721ApprovalForAll // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockERC721ApprovalForAllIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockERC721ApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockERC721ApprovalForAll) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockERC721ApprovalForAllIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockERC721ApprovalForAllIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockERC721ApprovalForAll represents a ApprovalForAll event raised by the MockERC721 contract. +type MockERC721ApprovalForAll struct { + Owner common.Address + Operator common.Address + Approved bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_MockERC721 *MockERC721Filterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*MockERC721ApprovalForAllIterator, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _MockERC721.contract.FilterLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return &MockERC721ApprovalForAllIterator{contract: _MockERC721.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil +} + +// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_MockERC721 *MockERC721Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *MockERC721ApprovalForAll, _owner []common.Address, _operator []common.Address) (event.Subscription, error) { + + var _ownerRule []interface{} + for _, _ownerItem := range _owner { + _ownerRule = append(_ownerRule, _ownerItem) + } + var _operatorRule []interface{} + for _, _operatorItem := range _operator { + _operatorRule = append(_operatorRule, _operatorItem) + } + + logs, sub, err := _MockERC721.contract.WatchLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockERC721ApprovalForAll) + if err := _MockERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31. +// +// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved) +func (_MockERC721 *MockERC721Filterer) ParseApprovalForAll(log types.Log) (*MockERC721ApprovalForAll, error) { + event := new(MockERC721ApprovalForAll) + if err := _MockERC721.contract.UnpackLog(event, "ApprovalForAll", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// MockERC721TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the MockERC721 contract. +type MockERC721TransferIterator struct { + Event *MockERC721Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *MockERC721TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(MockERC721Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(MockERC721Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *MockERC721TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *MockERC721TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// MockERC721Transfer represents a Transfer event raised by the MockERC721 contract. +type MockERC721Transfer struct { + From common.Address + To common.Address + TokenId *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) FilterTransfer(opts *bind.FilterOpts, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (*MockERC721TransferIterator, error) { + + var _fromRule []interface{} + for _, _fromItem := range _from { + _fromRule = append(_fromRule, _fromItem) + } + var _toRule []interface{} + for _, _toItem := range _to { + _toRule = append(_toRule, _toItem) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _MockERC721.contract.FilterLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return &MockERC721TransferIterator{contract: _MockERC721.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *MockERC721Transfer, _from []common.Address, _to []common.Address, _tokenId []*big.Int) (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) + } + var _tokenIdRule []interface{} + for _, _tokenIdItem := range _tokenId { + _tokenIdRule = append(_tokenIdRule, _tokenIdItem) + } + + logs, sub, err := _MockERC721.contract.WatchLogs(opts, "Transfer", _fromRule, _toRule, _tokenIdRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(MockERC721Transfer) + if err := _MockERC721.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId) +func (_MockERC721 *MockERC721Filterer) ParseTransfer(log types.Log) (*MockERC721Transfer, error) { + event := new(MockERC721Transfer) + if err := _MockERC721.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/safeconsole.sol/safeconsole.go b/pkg/forge-std/safeconsole.sol/safeconsole.go new file mode 100644 index 00000000..9d42f404 --- /dev/null +++ b/pkg/forge-std/safeconsole.sol/safeconsole.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package safeconsole + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// SafeconsoleMetaData contains all meta data concerning the Safeconsole contract. +var SafeconsoleMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220bda7fb78de2addc6c647ae8d0c202408646b0cd7d4e6a0df5ead8a8b63693e8a64736f6c63430008070033", +} + +// SafeconsoleABI is the input ABI used to generate the binding from. +// Deprecated: Use SafeconsoleMetaData.ABI instead. +var SafeconsoleABI = SafeconsoleMetaData.ABI + +// SafeconsoleBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use SafeconsoleMetaData.Bin instead. +var SafeconsoleBin = SafeconsoleMetaData.Bin + +// DeploySafeconsole deploys a new Ethereum contract, binding an instance of Safeconsole to it. +func DeploySafeconsole(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Safeconsole, error) { + parsed, err := SafeconsoleMetaData.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(SafeconsoleBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Safeconsole{SafeconsoleCaller: SafeconsoleCaller{contract: contract}, SafeconsoleTransactor: SafeconsoleTransactor{contract: contract}, SafeconsoleFilterer: SafeconsoleFilterer{contract: contract}}, nil +} + +// Safeconsole is an auto generated Go binding around an Ethereum contract. +type Safeconsole struct { + SafeconsoleCaller // Read-only binding to the contract + SafeconsoleTransactor // Write-only binding to the contract + SafeconsoleFilterer // Log filterer for contract events +} + +// SafeconsoleCaller is an auto generated read-only Go binding around an Ethereum contract. +type SafeconsoleCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeconsoleTransactor is an auto generated write-only Go binding around an Ethereum contract. +type SafeconsoleTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeconsoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type SafeconsoleFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeconsoleSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type SafeconsoleSession struct { + Contract *Safeconsole // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SafeconsoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type SafeconsoleCallerSession struct { + Contract *SafeconsoleCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// SafeconsoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type SafeconsoleTransactorSession struct { + Contract *SafeconsoleTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SafeconsoleRaw is an auto generated low-level Go binding around an Ethereum contract. +type SafeconsoleRaw struct { + Contract *Safeconsole // Generic contract binding to access the raw methods on +} + +// SafeconsoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type SafeconsoleCallerRaw struct { + Contract *SafeconsoleCaller // Generic read-only contract binding to access the raw methods on +} + +// SafeconsoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type SafeconsoleTransactorRaw struct { + Contract *SafeconsoleTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewSafeconsole creates a new instance of Safeconsole, bound to a specific deployed contract. +func NewSafeconsole(address common.Address, backend bind.ContractBackend) (*Safeconsole, error) { + contract, err := bindSafeconsole(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Safeconsole{SafeconsoleCaller: SafeconsoleCaller{contract: contract}, SafeconsoleTransactor: SafeconsoleTransactor{contract: contract}, SafeconsoleFilterer: SafeconsoleFilterer{contract: contract}}, nil +} + +// NewSafeconsoleCaller creates a new read-only instance of Safeconsole, bound to a specific deployed contract. +func NewSafeconsoleCaller(address common.Address, caller bind.ContractCaller) (*SafeconsoleCaller, error) { + contract, err := bindSafeconsole(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &SafeconsoleCaller{contract: contract}, nil +} + +// NewSafeconsoleTransactor creates a new write-only instance of Safeconsole, bound to a specific deployed contract. +func NewSafeconsoleTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeconsoleTransactor, error) { + contract, err := bindSafeconsole(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &SafeconsoleTransactor{contract: contract}, nil +} + +// NewSafeconsoleFilterer creates a new log filterer instance of Safeconsole, bound to a specific deployed contract. +func NewSafeconsoleFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeconsoleFilterer, error) { + contract, err := bindSafeconsole(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &SafeconsoleFilterer{contract: contract}, nil +} + +// bindSafeconsole binds a generic wrapper to an already deployed contract. +func bindSafeconsole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := SafeconsoleMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Safeconsole *SafeconsoleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Safeconsole.Contract.SafeconsoleCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Safeconsole *SafeconsoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Safeconsole.Contract.SafeconsoleTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Safeconsole *SafeconsoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Safeconsole.Contract.SafeconsoleTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Safeconsole *SafeconsoleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Safeconsole.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Safeconsole *SafeconsoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Safeconsole.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Safeconsole *SafeconsoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Safeconsole.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdassertions.sol/stdassertions.go b/pkg/forge-std/stdassertions.sol/stdassertions.go new file mode 100644 index 00000000..c6c42787 --- /dev/null +++ b/pkg/forge-std/stdassertions.sol/stdassertions.go @@ -0,0 +1,3173 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdassertions + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdAssertionsMetaData contains all meta data concerning the StdAssertions contract. +var StdAssertionsMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// StdAssertionsABI is the input ABI used to generate the binding from. +// Deprecated: Use StdAssertionsMetaData.ABI instead. +var StdAssertionsABI = StdAssertionsMetaData.ABI + +// StdAssertions is an auto generated Go binding around an Ethereum contract. +type StdAssertions struct { + StdAssertionsCaller // Read-only binding to the contract + StdAssertionsTransactor // Write-only binding to the contract + StdAssertionsFilterer // Log filterer for contract events +} + +// StdAssertionsCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdAssertionsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdAssertionsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdAssertionsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdAssertionsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdAssertionsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdAssertionsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdAssertionsSession struct { + Contract *StdAssertions // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdAssertionsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdAssertionsCallerSession struct { + Contract *StdAssertionsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdAssertionsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdAssertionsTransactorSession struct { + Contract *StdAssertionsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdAssertionsRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdAssertionsRaw struct { + Contract *StdAssertions // Generic contract binding to access the raw methods on +} + +// StdAssertionsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdAssertionsCallerRaw struct { + Contract *StdAssertionsCaller // Generic read-only contract binding to access the raw methods on +} + +// StdAssertionsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdAssertionsTransactorRaw struct { + Contract *StdAssertionsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdAssertions creates a new instance of StdAssertions, bound to a specific deployed contract. +func NewStdAssertions(address common.Address, backend bind.ContractBackend) (*StdAssertions, error) { + contract, err := bindStdAssertions(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdAssertions{StdAssertionsCaller: StdAssertionsCaller{contract: contract}, StdAssertionsTransactor: StdAssertionsTransactor{contract: contract}, StdAssertionsFilterer: StdAssertionsFilterer{contract: contract}}, nil +} + +// NewStdAssertionsCaller creates a new read-only instance of StdAssertions, bound to a specific deployed contract. +func NewStdAssertionsCaller(address common.Address, caller bind.ContractCaller) (*StdAssertionsCaller, error) { + contract, err := bindStdAssertions(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdAssertionsCaller{contract: contract}, nil +} + +// NewStdAssertionsTransactor creates a new write-only instance of StdAssertions, bound to a specific deployed contract. +func NewStdAssertionsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdAssertionsTransactor, error) { + contract, err := bindStdAssertions(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdAssertionsTransactor{contract: contract}, nil +} + +// NewStdAssertionsFilterer creates a new log filterer instance of StdAssertions, bound to a specific deployed contract. +func NewStdAssertionsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdAssertionsFilterer, error) { + contract, err := bindStdAssertions(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdAssertionsFilterer{contract: contract}, nil +} + +// bindStdAssertions binds a generic wrapper to an already deployed contract. +func bindStdAssertions(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdAssertionsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdAssertions *StdAssertionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdAssertions.Contract.StdAssertionsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdAssertions *StdAssertionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdAssertions.Contract.StdAssertionsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdAssertions *StdAssertionsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdAssertions.Contract.StdAssertionsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdAssertions *StdAssertionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdAssertions.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdAssertions *StdAssertionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdAssertions.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdAssertions *StdAssertionsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdAssertions.Contract.contract.Transact(opts, method, params...) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_StdAssertions *StdAssertionsCaller) Failed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _StdAssertions.contract.Call(opts, &out, "failed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_StdAssertions *StdAssertionsSession) Failed() (bool, error) { + return _StdAssertions.Contract.Failed(&_StdAssertions.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_StdAssertions *StdAssertionsCallerSession) Failed() (bool, error) { + return _StdAssertions.Contract.Failed(&_StdAssertions.CallOpts) +} + +// StdAssertionsLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the StdAssertions contract. +type StdAssertionsLogIterator struct { + Event *StdAssertionsLog // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLog represents a Log event raised by the StdAssertions contract. +type StdAssertionsLog struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLog(opts *bind.FilterOpts) (*StdAssertionsLogIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log") + if err != nil { + return nil, err + } + return &StdAssertionsLogIterator{contract: _StdAssertions.contract, event: "log", logs: logs, sub: sub}, nil +} + +// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *StdAssertionsLog) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLog) + if err := _StdAssertions.contract.UnpackLog(event, "log", 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 +} + +// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLog(log types.Log) (*StdAssertionsLog, error) { + event := new(StdAssertionsLog) + if err := _StdAssertions.contract.UnpackLog(event, "log", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the StdAssertions contract. +type StdAssertionsLogAddressIterator struct { + Event *StdAssertionsLogAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogAddress represents a LogAddress event raised by the StdAssertions contract. +type StdAssertionsLogAddress struct { + Arg0 common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogAddress(opts *bind.FilterOpts) (*StdAssertionsLogAddressIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_address") + if err != nil { + return nil, err + } + return &StdAssertionsLogAddressIterator{contract: _StdAssertions.contract, event: "log_address", logs: logs, sub: sub}, nil +} + +// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogAddress) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogAddress) + if err := _StdAssertions.contract.UnpackLog(event, "log_address", 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 +} + +// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogAddress(log types.Log) (*StdAssertionsLogAddress, error) { + event := new(StdAssertionsLogAddress) + if err := _StdAssertions.contract.UnpackLog(event, "log_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the StdAssertions contract. +type StdAssertionsLogArrayIterator struct { + Event *StdAssertionsLogArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogArray represents a LogArray event raised by the StdAssertions contract. +type StdAssertionsLogArray struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogArray(opts *bind.FilterOpts) (*StdAssertionsLogArrayIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array") + if err != nil { + return nil, err + } + return &StdAssertionsLogArrayIterator{contract: _StdAssertions.contract, event: "log_array", logs: logs, sub: sub}, nil +} + +// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogArray) + if err := _StdAssertions.contract.UnpackLog(event, "log_array", 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 +} + +// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogArray(log types.Log) (*StdAssertionsLogArray, error) { + event := new(StdAssertionsLogArray) + if err := _StdAssertions.contract.UnpackLog(event, "log_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the StdAssertions contract. +type StdAssertionsLogArray0Iterator struct { + Event *StdAssertionsLogArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogArray0 represents a LogArray0 event raised by the StdAssertions contract. +type StdAssertionsLogArray0 struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogArray0(opts *bind.FilterOpts) (*StdAssertionsLogArray0Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return &StdAssertionsLogArray0Iterator{contract: _StdAssertions.contract, event: "log_array0", logs: logs, sub: sub}, nil +} + +// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray0) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogArray0) + if err := _StdAssertions.contract.UnpackLog(event, "log_array0", 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 +} + +// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogArray0(log types.Log) (*StdAssertionsLogArray0, error) { + event := new(StdAssertionsLogArray0) + if err := _StdAssertions.contract.UnpackLog(event, "log_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the StdAssertions contract. +type StdAssertionsLogArray1Iterator struct { + Event *StdAssertionsLogArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogArray1 represents a LogArray1 event raised by the StdAssertions contract. +type StdAssertionsLogArray1 struct { + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogArray1(opts *bind.FilterOpts) (*StdAssertionsLogArray1Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return &StdAssertionsLogArray1Iterator{contract: _StdAssertions.contract, event: "log_array1", logs: logs, sub: sub}, nil +} + +// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogArray1) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogArray1) + if err := _StdAssertions.contract.UnpackLog(event, "log_array1", 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 +} + +// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogArray1(log types.Log) (*StdAssertionsLogArray1, error) { + event := new(StdAssertionsLogArray1) + if err := _StdAssertions.contract.UnpackLog(event, "log_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the StdAssertions contract. +type StdAssertionsLogBytesIterator struct { + Event *StdAssertionsLogBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogBytes represents a LogBytes event raised by the StdAssertions contract. +type StdAssertionsLogBytes struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogBytes(opts *bind.FilterOpts) (*StdAssertionsLogBytesIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return &StdAssertionsLogBytesIterator{contract: _StdAssertions.contract, event: "log_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogBytes) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogBytes) + if err := _StdAssertions.contract.UnpackLog(event, "log_bytes", 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 +} + +// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogBytes(log types.Log) (*StdAssertionsLogBytes, error) { + event := new(StdAssertionsLogBytes) + if err := _StdAssertions.contract.UnpackLog(event, "log_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the StdAssertions contract. +type StdAssertionsLogBytes32Iterator struct { + Event *StdAssertionsLogBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogBytes32 represents a LogBytes32 event raised by the StdAssertions contract. +type StdAssertionsLogBytes32 struct { + Arg0 [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*StdAssertionsLogBytes32Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return &StdAssertionsLogBytes32Iterator{contract: _StdAssertions.contract, event: "log_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogBytes32) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogBytes32) + if err := _StdAssertions.contract.UnpackLog(event, "log_bytes32", 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 +} + +// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogBytes32(log types.Log) (*StdAssertionsLogBytes32, error) { + event := new(StdAssertionsLogBytes32) + if err := _StdAssertions.contract.UnpackLog(event, "log_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the StdAssertions contract. +type StdAssertionsLogIntIterator struct { + Event *StdAssertionsLogInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogInt represents a LogInt event raised by the StdAssertions contract. +type StdAssertionsLogInt struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogInt(opts *bind.FilterOpts) (*StdAssertionsLogIntIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_int") + if err != nil { + return nil, err + } + return &StdAssertionsLogIntIterator{contract: _StdAssertions.contract, event: "log_int", logs: logs, sub: sub}, nil +} + +// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogInt) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_int", 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 +} + +// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogInt(log types.Log) (*StdAssertionsLogInt, error) { + event := new(StdAssertionsLogInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the StdAssertions contract. +type StdAssertionsLogNamedAddressIterator struct { + Event *StdAssertionsLogNamedAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedAddress represents a LogNamedAddress event raised by the StdAssertions contract. +type StdAssertionsLogNamedAddress struct { + Key string + Val common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*StdAssertionsLogNamedAddressIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedAddressIterator{contract: _StdAssertions.contract, event: "log_named_address", logs: logs, sub: sub}, nil +} + +// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedAddress) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedAddress) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_address", 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 +} + +// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedAddress(log types.Log) (*StdAssertionsLogNamedAddress, error) { + event := new(StdAssertionsLogNamedAddress) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the StdAssertions contract. +type StdAssertionsLogNamedArrayIterator struct { + Event *StdAssertionsLogNamedArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedArray represents a LogNamedArray event raised by the StdAssertions contract. +type StdAssertionsLogNamedArray struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*StdAssertionsLogNamedArrayIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedArrayIterator{contract: _StdAssertions.contract, event: "log_named_array", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedArray) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array", 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 +} + +// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray(log types.Log) (*StdAssertionsLogNamedArray, error) { + event := new(StdAssertionsLogNamedArray) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the StdAssertions contract. +type StdAssertionsLogNamedArray0Iterator struct { + Event *StdAssertionsLogNamedArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedArray0 represents a LogNamedArray0 event raised by the StdAssertions contract. +type StdAssertionsLogNamedArray0 struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*StdAssertionsLogNamedArray0Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedArray0Iterator{contract: _StdAssertions.contract, event: "log_named_array0", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray0) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedArray0) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array0", 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 +} + +// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray0(log types.Log) (*StdAssertionsLogNamedArray0, error) { + event := new(StdAssertionsLogNamedArray0) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the StdAssertions contract. +type StdAssertionsLogNamedArray1Iterator struct { + Event *StdAssertionsLogNamedArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedArray1 represents a LogNamedArray1 event raised by the StdAssertions contract. +type StdAssertionsLogNamedArray1 struct { + Key string + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*StdAssertionsLogNamedArray1Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedArray1Iterator{contract: _StdAssertions.contract, event: "log_named_array1", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedArray1) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedArray1) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array1", 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 +} + +// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedArray1(log types.Log) (*StdAssertionsLogNamedArray1, error) { + event := new(StdAssertionsLogNamedArray1) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the StdAssertions contract. +type StdAssertionsLogNamedBytesIterator struct { + Event *StdAssertionsLogNamedBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedBytes represents a LogNamedBytes event raised by the StdAssertions contract. +type StdAssertionsLogNamedBytes struct { + Key string + Val []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*StdAssertionsLogNamedBytesIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedBytesIterator{contract: _StdAssertions.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedBytes) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedBytes) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes", 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 +} + +// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedBytes(log types.Log) (*StdAssertionsLogNamedBytes, error) { + event := new(StdAssertionsLogNamedBytes) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the StdAssertions contract. +type StdAssertionsLogNamedBytes32Iterator struct { + Event *StdAssertionsLogNamedBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedBytes32 represents a LogNamedBytes32 event raised by the StdAssertions contract. +type StdAssertionsLogNamedBytes32 struct { + Key string + Val [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*StdAssertionsLogNamedBytes32Iterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedBytes32Iterator{contract: _StdAssertions.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedBytes32) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedBytes32) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes32", 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 +} + +// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedBytes32(log types.Log) (*StdAssertionsLogNamedBytes32, error) { + event := new(StdAssertionsLogNamedBytes32) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the StdAssertions contract. +type StdAssertionsLogNamedDecimalIntIterator struct { + Event *StdAssertionsLogNamedDecimalInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedDecimalIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedDecimalIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedDecimalIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the StdAssertions contract. +type StdAssertionsLogNamedDecimalInt struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*StdAssertionsLogNamedDecimalIntIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedDecimalIntIterator{contract: _StdAssertions.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedDecimalInt) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedDecimalInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_int", 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 +} + +// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedDecimalInt(log types.Log) (*StdAssertionsLogNamedDecimalInt, error) { + event := new(StdAssertionsLogNamedDecimalInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the StdAssertions contract. +type StdAssertionsLogNamedDecimalUintIterator struct { + Event *StdAssertionsLogNamedDecimalUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedDecimalUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedDecimalUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedDecimalUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the StdAssertions contract. +type StdAssertionsLogNamedDecimalUint struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*StdAssertionsLogNamedDecimalUintIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedDecimalUintIterator{contract: _StdAssertions.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedDecimalUint) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedDecimalUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_uint", 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 +} + +// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedDecimalUint(log types.Log) (*StdAssertionsLogNamedDecimalUint, error) { + event := new(StdAssertionsLogNamedDecimalUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the StdAssertions contract. +type StdAssertionsLogNamedIntIterator struct { + Event *StdAssertionsLogNamedInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedInt represents a LogNamedInt event raised by the StdAssertions contract. +type StdAssertionsLogNamedInt struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*StdAssertionsLogNamedIntIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedIntIterator{contract: _StdAssertions.contract, event: "log_named_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedInt) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_int", 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 +} + +// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedInt(log types.Log) (*StdAssertionsLogNamedInt, error) { + event := new(StdAssertionsLogNamedInt) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the StdAssertions contract. +type StdAssertionsLogNamedStringIterator struct { + Event *StdAssertionsLogNamedString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedString represents a LogNamedString event raised by the StdAssertions contract. +type StdAssertionsLogNamedString struct { + Key string + Val string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*StdAssertionsLogNamedStringIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedStringIterator{contract: _StdAssertions.contract, event: "log_named_string", logs: logs, sub: sub}, nil +} + +// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedString) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedString) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_string", 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 +} + +// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedString(log types.Log) (*StdAssertionsLogNamedString, error) { + event := new(StdAssertionsLogNamedString) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the StdAssertions contract. +type StdAssertionsLogNamedUintIterator struct { + Event *StdAssertionsLogNamedUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogNamedUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogNamedUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogNamedUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogNamedUint represents a LogNamedUint event raised by the StdAssertions contract. +type StdAssertionsLogNamedUint struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_StdAssertions *StdAssertionsFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*StdAssertionsLogNamedUintIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return &StdAssertionsLogNamedUintIterator{contract: _StdAssertions.contract, event: "log_named_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_StdAssertions *StdAssertionsFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogNamedUint) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogNamedUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_uint", 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 +} + +// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_StdAssertions *StdAssertionsFilterer) ParseLogNamedUint(log types.Log) (*StdAssertionsLogNamedUint, error) { + event := new(StdAssertionsLogNamedUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_named_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the StdAssertions contract. +type StdAssertionsLogStringIterator struct { + Event *StdAssertionsLogString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogString represents a LogString event raised by the StdAssertions contract. +type StdAssertionsLogString struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogString(opts *bind.FilterOpts) (*StdAssertionsLogStringIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_string") + if err != nil { + return nil, err + } + return &StdAssertionsLogStringIterator{contract: _StdAssertions.contract, event: "log_string", logs: logs, sub: sub}, nil +} + +// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogString) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogString) + if err := _StdAssertions.contract.UnpackLog(event, "log_string", 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 +} + +// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogString(log types.Log) (*StdAssertionsLogString, error) { + event := new(StdAssertionsLogString) + if err := _StdAssertions.contract.UnpackLog(event, "log_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the StdAssertions contract. +type StdAssertionsLogUintIterator struct { + Event *StdAssertionsLogUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogUint represents a LogUint event raised by the StdAssertions contract. +type StdAssertionsLogUint struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogUint(opts *bind.FilterOpts) (*StdAssertionsLogUintIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return &StdAssertionsLogUintIterator{contract: _StdAssertions.contract, event: "log_uint", logs: logs, sub: sub}, nil +} + +// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogUint) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_uint", 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 +} + +// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogUint(log types.Log) (*StdAssertionsLogUint, error) { + event := new(StdAssertionsLogUint) + if err := _StdAssertions.contract.UnpackLog(event, "log_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdAssertionsLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the StdAssertions contract. +type StdAssertionsLogsIterator struct { + Event *StdAssertionsLogs // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdAssertionsLogsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdAssertionsLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdAssertionsLogsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdAssertionsLogsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdAssertionsLogs represents a Logs event raised by the StdAssertions contract. +type StdAssertionsLogs struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) FilterLogs(opts *bind.FilterOpts) (*StdAssertionsLogsIterator, error) { + + logs, sub, err := _StdAssertions.contract.FilterLogs(opts, "logs") + if err != nil { + return nil, err + } + return &StdAssertionsLogsIterator{contract: _StdAssertions.contract, event: "logs", logs: logs, sub: sub}, nil +} + +// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *StdAssertionsLogs) (event.Subscription, error) { + + logs, sub, err := _StdAssertions.contract.WatchLogs(opts, "logs") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdAssertionsLogs) + if err := _StdAssertions.contract.UnpackLog(event, "logs", 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 +} + +// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_StdAssertions *StdAssertionsFilterer) ParseLogs(log types.Log) (*StdAssertionsLogs, error) { + event := new(StdAssertionsLogs) + if err := _StdAssertions.contract.UnpackLog(event, "logs", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/stdchains.sol/stdchains.go b/pkg/forge-std/stdchains.sol/stdchains.go new file mode 100644 index 00000000..440f138f --- /dev/null +++ b/pkg/forge-std/stdchains.sol/stdchains.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdchains + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdChainsMetaData contains all meta data concerning the StdChains contract. +var StdChainsMetaData = &bind.MetaData{ + ABI: "[]", +} + +// StdChainsABI is the input ABI used to generate the binding from. +// Deprecated: Use StdChainsMetaData.ABI instead. +var StdChainsABI = StdChainsMetaData.ABI + +// StdChains is an auto generated Go binding around an Ethereum contract. +type StdChains struct { + StdChainsCaller // Read-only binding to the contract + StdChainsTransactor // Write-only binding to the contract + StdChainsFilterer // Log filterer for contract events +} + +// StdChainsCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdChainsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdChainsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdChainsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdChainsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdChainsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdChainsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdChainsSession struct { + Contract *StdChains // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdChainsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdChainsCallerSession struct { + Contract *StdChainsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdChainsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdChainsTransactorSession struct { + Contract *StdChainsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdChainsRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdChainsRaw struct { + Contract *StdChains // Generic contract binding to access the raw methods on +} + +// StdChainsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdChainsCallerRaw struct { + Contract *StdChainsCaller // Generic read-only contract binding to access the raw methods on +} + +// StdChainsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdChainsTransactorRaw struct { + Contract *StdChainsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdChains creates a new instance of StdChains, bound to a specific deployed contract. +func NewStdChains(address common.Address, backend bind.ContractBackend) (*StdChains, error) { + contract, err := bindStdChains(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdChains{StdChainsCaller: StdChainsCaller{contract: contract}, StdChainsTransactor: StdChainsTransactor{contract: contract}, StdChainsFilterer: StdChainsFilterer{contract: contract}}, nil +} + +// NewStdChainsCaller creates a new read-only instance of StdChains, bound to a specific deployed contract. +func NewStdChainsCaller(address common.Address, caller bind.ContractCaller) (*StdChainsCaller, error) { + contract, err := bindStdChains(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdChainsCaller{contract: contract}, nil +} + +// NewStdChainsTransactor creates a new write-only instance of StdChains, bound to a specific deployed contract. +func NewStdChainsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdChainsTransactor, error) { + contract, err := bindStdChains(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdChainsTransactor{contract: contract}, nil +} + +// NewStdChainsFilterer creates a new log filterer instance of StdChains, bound to a specific deployed contract. +func NewStdChainsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdChainsFilterer, error) { + contract, err := bindStdChains(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdChainsFilterer{contract: contract}, nil +} + +// bindStdChains binds a generic wrapper to an already deployed contract. +func bindStdChains(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdChainsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdChains *StdChainsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdChains.Contract.StdChainsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdChains *StdChainsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdChains.Contract.StdChainsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdChains *StdChainsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdChains.Contract.StdChainsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdChains *StdChainsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdChains.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdChains *StdChainsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdChains.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdChains *StdChainsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdChains.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdcheats.sol/stdcheats.go b/pkg/forge-std/stdcheats.sol/stdcheats.go new file mode 100644 index 00000000..434d8176 --- /dev/null +++ b/pkg/forge-std/stdcheats.sol/stdcheats.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdcheats + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdCheatsMetaData contains all meta data concerning the StdCheats contract. +var StdCheatsMetaData = &bind.MetaData{ + ABI: "[]", +} + +// StdCheatsABI is the input ABI used to generate the binding from. +// Deprecated: Use StdCheatsMetaData.ABI instead. +var StdCheatsABI = StdCheatsMetaData.ABI + +// StdCheats is an auto generated Go binding around an Ethereum contract. +type StdCheats struct { + StdCheatsCaller // Read-only binding to the contract + StdCheatsTransactor // Write-only binding to the contract + StdCheatsFilterer // Log filterer for contract events +} + +// StdCheatsCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdCheatsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdCheatsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdCheatsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdCheatsSession struct { + Contract *StdCheats // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdCheatsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdCheatsCallerSession struct { + Contract *StdCheatsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdCheatsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdCheatsTransactorSession struct { + Contract *StdCheatsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdCheatsRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdCheatsRaw struct { + Contract *StdCheats // Generic contract binding to access the raw methods on +} + +// StdCheatsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdCheatsCallerRaw struct { + Contract *StdCheatsCaller // Generic read-only contract binding to access the raw methods on +} + +// StdCheatsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdCheatsTransactorRaw struct { + Contract *StdCheatsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdCheats creates a new instance of StdCheats, bound to a specific deployed contract. +func NewStdCheats(address common.Address, backend bind.ContractBackend) (*StdCheats, error) { + contract, err := bindStdCheats(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdCheats{StdCheatsCaller: StdCheatsCaller{contract: contract}, StdCheatsTransactor: StdCheatsTransactor{contract: contract}, StdCheatsFilterer: StdCheatsFilterer{contract: contract}}, nil +} + +// NewStdCheatsCaller creates a new read-only instance of StdCheats, bound to a specific deployed contract. +func NewStdCheatsCaller(address common.Address, caller bind.ContractCaller) (*StdCheatsCaller, error) { + contract, err := bindStdCheats(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdCheatsCaller{contract: contract}, nil +} + +// NewStdCheatsTransactor creates a new write-only instance of StdCheats, bound to a specific deployed contract. +func NewStdCheatsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdCheatsTransactor, error) { + contract, err := bindStdCheats(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdCheatsTransactor{contract: contract}, nil +} + +// NewStdCheatsFilterer creates a new log filterer instance of StdCheats, bound to a specific deployed contract. +func NewStdCheatsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdCheatsFilterer, error) { + contract, err := bindStdCheats(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdCheatsFilterer{contract: contract}, nil +} + +// bindStdCheats binds a generic wrapper to an already deployed contract. +func bindStdCheats(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdCheatsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdCheats *StdCheatsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdCheats.Contract.StdCheatsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdCheats *StdCheatsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdCheats.Contract.StdCheatsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdCheats *StdCheatsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdCheats.Contract.StdCheatsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdCheats *StdCheatsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdCheats.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdCheats *StdCheatsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdCheats.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdCheats *StdCheatsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdCheats.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdcheats.sol/stdcheatssafe.go b/pkg/forge-std/stdcheats.sol/stdcheatssafe.go new file mode 100644 index 00000000..4ccb96d0 --- /dev/null +++ b/pkg/forge-std/stdcheats.sol/stdcheatssafe.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdcheats + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdCheatsSafeMetaData contains all meta data concerning the StdCheatsSafe contract. +var StdCheatsSafeMetaData = &bind.MetaData{ + ABI: "[]", +} + +// StdCheatsSafeABI is the input ABI used to generate the binding from. +// Deprecated: Use StdCheatsSafeMetaData.ABI instead. +var StdCheatsSafeABI = StdCheatsSafeMetaData.ABI + +// StdCheatsSafe is an auto generated Go binding around an Ethereum contract. +type StdCheatsSafe struct { + StdCheatsSafeCaller // Read-only binding to the contract + StdCheatsSafeTransactor // Write-only binding to the contract + StdCheatsSafeFilterer // Log filterer for contract events +} + +// StdCheatsSafeCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdCheatsSafeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsSafeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdCheatsSafeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdCheatsSafeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdCheatsSafeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdCheatsSafeSession struct { + Contract *StdCheatsSafe // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdCheatsSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdCheatsSafeCallerSession struct { + Contract *StdCheatsSafeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdCheatsSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdCheatsSafeTransactorSession struct { + Contract *StdCheatsSafeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdCheatsSafeRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdCheatsSafeRaw struct { + Contract *StdCheatsSafe // Generic contract binding to access the raw methods on +} + +// StdCheatsSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdCheatsSafeCallerRaw struct { + Contract *StdCheatsSafeCaller // Generic read-only contract binding to access the raw methods on +} + +// StdCheatsSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdCheatsSafeTransactorRaw struct { + Contract *StdCheatsSafeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdCheatsSafe creates a new instance of StdCheatsSafe, bound to a specific deployed contract. +func NewStdCheatsSafe(address common.Address, backend bind.ContractBackend) (*StdCheatsSafe, error) { + contract, err := bindStdCheatsSafe(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdCheatsSafe{StdCheatsSafeCaller: StdCheatsSafeCaller{contract: contract}, StdCheatsSafeTransactor: StdCheatsSafeTransactor{contract: contract}, StdCheatsSafeFilterer: StdCheatsSafeFilterer{contract: contract}}, nil +} + +// NewStdCheatsSafeCaller creates a new read-only instance of StdCheatsSafe, bound to a specific deployed contract. +func NewStdCheatsSafeCaller(address common.Address, caller bind.ContractCaller) (*StdCheatsSafeCaller, error) { + contract, err := bindStdCheatsSafe(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdCheatsSafeCaller{contract: contract}, nil +} + +// NewStdCheatsSafeTransactor creates a new write-only instance of StdCheatsSafe, bound to a specific deployed contract. +func NewStdCheatsSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*StdCheatsSafeTransactor, error) { + contract, err := bindStdCheatsSafe(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdCheatsSafeTransactor{contract: contract}, nil +} + +// NewStdCheatsSafeFilterer creates a new log filterer instance of StdCheatsSafe, bound to a specific deployed contract. +func NewStdCheatsSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*StdCheatsSafeFilterer, error) { + contract, err := bindStdCheatsSafe(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdCheatsSafeFilterer{contract: contract}, nil +} + +// bindStdCheatsSafe binds a generic wrapper to an already deployed contract. +func bindStdCheatsSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdCheatsSafeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdCheatsSafe *StdCheatsSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdCheatsSafe.Contract.StdCheatsSafeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdCheatsSafe *StdCheatsSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdCheatsSafe.Contract.StdCheatsSafeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdCheatsSafe *StdCheatsSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdCheatsSafe.Contract.StdCheatsSafeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdCheatsSafe *StdCheatsSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdCheatsSafe.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdCheatsSafe *StdCheatsSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdCheatsSafe.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdCheatsSafe *StdCheatsSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdCheatsSafe.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stderror.sol/stderror.go b/pkg/forge-std/stderror.sol/stderror.go new file mode 100644 index 00000000..af401f89 --- /dev/null +++ b/pkg/forge-std/stderror.sol/stderror.go @@ -0,0 +1,482 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stderror + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdErrorMetaData contains all meta data concerning the StdError contract. +var StdErrorMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"arithmeticError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"assertionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"divisionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"encodeStorageError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"enumConversionError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"indexOOBError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"memOverflowError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"popError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeroVarError\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// StdErrorABI is the input ABI used to generate the binding from. +// Deprecated: Use StdErrorMetaData.ABI instead. +var StdErrorABI = StdErrorMetaData.ABI + +// StdErrorBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdErrorMetaData.Bin instead. +var StdErrorBin = StdErrorMetaData.Bin + +// DeployStdError deploys a new Ethereum contract, binding an instance of StdError to it. +func DeployStdError(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdError, error) { + parsed, err := StdErrorMetaData.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(StdErrorBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdError{StdErrorCaller: StdErrorCaller{contract: contract}, StdErrorTransactor: StdErrorTransactor{contract: contract}, StdErrorFilterer: StdErrorFilterer{contract: contract}}, nil +} + +// StdError is an auto generated Go binding around an Ethereum contract. +type StdError struct { + StdErrorCaller // Read-only binding to the contract + StdErrorTransactor // Write-only binding to the contract + StdErrorFilterer // Log filterer for contract events +} + +// StdErrorCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdErrorCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdErrorTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdErrorTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdErrorFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdErrorFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdErrorSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdErrorSession struct { + Contract *StdError // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdErrorCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdErrorCallerSession struct { + Contract *StdErrorCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdErrorTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdErrorTransactorSession struct { + Contract *StdErrorTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdErrorRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdErrorRaw struct { + Contract *StdError // Generic contract binding to access the raw methods on +} + +// StdErrorCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdErrorCallerRaw struct { + Contract *StdErrorCaller // Generic read-only contract binding to access the raw methods on +} + +// StdErrorTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdErrorTransactorRaw struct { + Contract *StdErrorTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdError creates a new instance of StdError, bound to a specific deployed contract. +func NewStdError(address common.Address, backend bind.ContractBackend) (*StdError, error) { + contract, err := bindStdError(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdError{StdErrorCaller: StdErrorCaller{contract: contract}, StdErrorTransactor: StdErrorTransactor{contract: contract}, StdErrorFilterer: StdErrorFilterer{contract: contract}}, nil +} + +// NewStdErrorCaller creates a new read-only instance of StdError, bound to a specific deployed contract. +func NewStdErrorCaller(address common.Address, caller bind.ContractCaller) (*StdErrorCaller, error) { + contract, err := bindStdError(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdErrorCaller{contract: contract}, nil +} + +// NewStdErrorTransactor creates a new write-only instance of StdError, bound to a specific deployed contract. +func NewStdErrorTransactor(address common.Address, transactor bind.ContractTransactor) (*StdErrorTransactor, error) { + contract, err := bindStdError(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdErrorTransactor{contract: contract}, nil +} + +// NewStdErrorFilterer creates a new log filterer instance of StdError, bound to a specific deployed contract. +func NewStdErrorFilterer(address common.Address, filterer bind.ContractFilterer) (*StdErrorFilterer, error) { + contract, err := bindStdError(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdErrorFilterer{contract: contract}, nil +} + +// bindStdError binds a generic wrapper to an already deployed contract. +func bindStdError(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdErrorMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdError *StdErrorRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdError.Contract.StdErrorCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdError *StdErrorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdError.Contract.StdErrorTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdError *StdErrorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdError.Contract.StdErrorTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdError *StdErrorCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdError.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdError *StdErrorTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdError.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdError *StdErrorTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdError.Contract.contract.Transact(opts, method, params...) +} + +// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f. +// +// Solidity: function arithmeticError() view returns(bytes) +func (_StdError *StdErrorCaller) ArithmeticError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "arithmeticError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f. +// +// Solidity: function arithmeticError() view returns(bytes) +func (_StdError *StdErrorSession) ArithmeticError() ([]byte, error) { + return _StdError.Contract.ArithmeticError(&_StdError.CallOpts) +} + +// ArithmeticError is a free data retrieval call binding the contract method 0x8995290f. +// +// Solidity: function arithmeticError() view returns(bytes) +func (_StdError *StdErrorCallerSession) ArithmeticError() ([]byte, error) { + return _StdError.Contract.ArithmeticError(&_StdError.CallOpts) +} + +// AssertionError is a free data retrieval call binding the contract method 0x10332977. +// +// Solidity: function assertionError() view returns(bytes) +func (_StdError *StdErrorCaller) AssertionError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "assertionError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// AssertionError is a free data retrieval call binding the contract method 0x10332977. +// +// Solidity: function assertionError() view returns(bytes) +func (_StdError *StdErrorSession) AssertionError() ([]byte, error) { + return _StdError.Contract.AssertionError(&_StdError.CallOpts) +} + +// AssertionError is a free data retrieval call binding the contract method 0x10332977. +// +// Solidity: function assertionError() view returns(bytes) +func (_StdError *StdErrorCallerSession) AssertionError() ([]byte, error) { + return _StdError.Contract.AssertionError(&_StdError.CallOpts) +} + +// DivisionError is a free data retrieval call binding the contract method 0xfa784a44. +// +// Solidity: function divisionError() view returns(bytes) +func (_StdError *StdErrorCaller) DivisionError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "divisionError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// DivisionError is a free data retrieval call binding the contract method 0xfa784a44. +// +// Solidity: function divisionError() view returns(bytes) +func (_StdError *StdErrorSession) DivisionError() ([]byte, error) { + return _StdError.Contract.DivisionError(&_StdError.CallOpts) +} + +// DivisionError is a free data retrieval call binding the contract method 0xfa784a44. +// +// Solidity: function divisionError() view returns(bytes) +func (_StdError *StdErrorCallerSession) DivisionError() ([]byte, error) { + return _StdError.Contract.DivisionError(&_StdError.CallOpts) +} + +// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de. +// +// Solidity: function encodeStorageError() view returns(bytes) +func (_StdError *StdErrorCaller) EncodeStorageError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "encodeStorageError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de. +// +// Solidity: function encodeStorageError() view returns(bytes) +func (_StdError *StdErrorSession) EncodeStorageError() ([]byte, error) { + return _StdError.Contract.EncodeStorageError(&_StdError.CallOpts) +} + +// EncodeStorageError is a free data retrieval call binding the contract method 0xd160e4de. +// +// Solidity: function encodeStorageError() view returns(bytes) +func (_StdError *StdErrorCallerSession) EncodeStorageError() ([]byte, error) { + return _StdError.Contract.EncodeStorageError(&_StdError.CallOpts) +} + +// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560. +// +// Solidity: function enumConversionError() view returns(bytes) +func (_StdError *StdErrorCaller) EnumConversionError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "enumConversionError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560. +// +// Solidity: function enumConversionError() view returns(bytes) +func (_StdError *StdErrorSession) EnumConversionError() ([]byte, error) { + return _StdError.Contract.EnumConversionError(&_StdError.CallOpts) +} + +// EnumConversionError is a free data retrieval call binding the contract method 0x1de45560. +// +// Solidity: function enumConversionError() view returns(bytes) +func (_StdError *StdErrorCallerSession) EnumConversionError() ([]byte, error) { + return _StdError.Contract.EnumConversionError(&_StdError.CallOpts) +} + +// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612. +// +// Solidity: function indexOOBError() view returns(bytes) +func (_StdError *StdErrorCaller) IndexOOBError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "indexOOBError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612. +// +// Solidity: function indexOOBError() view returns(bytes) +func (_StdError *StdErrorSession) IndexOOBError() ([]byte, error) { + return _StdError.Contract.IndexOOBError(&_StdError.CallOpts) +} + +// IndexOOBError is a free data retrieval call binding the contract method 0x05ee8612. +// +// Solidity: function indexOOBError() view returns(bytes) +func (_StdError *StdErrorCallerSession) IndexOOBError() ([]byte, error) { + return _StdError.Contract.IndexOOBError(&_StdError.CallOpts) +} + +// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68. +// +// Solidity: function memOverflowError() view returns(bytes) +func (_StdError *StdErrorCaller) MemOverflowError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "memOverflowError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68. +// +// Solidity: function memOverflowError() view returns(bytes) +func (_StdError *StdErrorSession) MemOverflowError() ([]byte, error) { + return _StdError.Contract.MemOverflowError(&_StdError.CallOpts) +} + +// MemOverflowError is a free data retrieval call binding the contract method 0x986c5f68. +// +// Solidity: function memOverflowError() view returns(bytes) +func (_StdError *StdErrorCallerSession) MemOverflowError() ([]byte, error) { + return _StdError.Contract.MemOverflowError(&_StdError.CallOpts) +} + +// PopError is a free data retrieval call binding the contract method 0xb22dc54d. +// +// Solidity: function popError() view returns(bytes) +func (_StdError *StdErrorCaller) PopError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "popError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// PopError is a free data retrieval call binding the contract method 0xb22dc54d. +// +// Solidity: function popError() view returns(bytes) +func (_StdError *StdErrorSession) PopError() ([]byte, error) { + return _StdError.Contract.PopError(&_StdError.CallOpts) +} + +// PopError is a free data retrieval call binding the contract method 0xb22dc54d. +// +// Solidity: function popError() view returns(bytes) +func (_StdError *StdErrorCallerSession) PopError() ([]byte, error) { + return _StdError.Contract.PopError(&_StdError.CallOpts) +} + +// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da. +// +// Solidity: function zeroVarError() view returns(bytes) +func (_StdError *StdErrorCaller) ZeroVarError(opts *bind.CallOpts) ([]byte, error) { + var out []interface{} + err := _StdError.contract.Call(opts, &out, "zeroVarError") + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da. +// +// Solidity: function zeroVarError() view returns(bytes) +func (_StdError *StdErrorSession) ZeroVarError() ([]byte, error) { + return _StdError.Contract.ZeroVarError(&_StdError.CallOpts) +} + +// ZeroVarError is a free data retrieval call binding the contract method 0xb67689da. +// +// Solidity: function zeroVarError() view returns(bytes) +func (_StdError *StdErrorCallerSession) ZeroVarError() ([]byte, error) { + return _StdError.Contract.ZeroVarError(&_StdError.CallOpts) +} diff --git a/pkg/forge-std/stdinvariant.sol/stdinvariant.go b/pkg/forge-std/stdinvariant.sol/stdinvariant.go new file mode 100644 index 00000000..48b1bba4 --- /dev/null +++ b/pkg/forge-std/stdinvariant.sol/stdinvariant.go @@ -0,0 +1,509 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdinvariant + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdInvariantFuzzArtifactSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzArtifactSelector struct { + Artifact string + Selectors [][4]byte +} + +// StdInvariantFuzzInterface is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzInterface struct { + Addr common.Address + Artifacts []string +} + +// StdInvariantFuzzSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzSelector struct { + Addr common.Address + Selectors [][4]byte +} + +// StdInvariantMetaData contains all meta data concerning the StdInvariant contract. +var StdInvariantMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// StdInvariantABI is the input ABI used to generate the binding from. +// Deprecated: Use StdInvariantMetaData.ABI instead. +var StdInvariantABI = StdInvariantMetaData.ABI + +// StdInvariant is an auto generated Go binding around an Ethereum contract. +type StdInvariant struct { + StdInvariantCaller // Read-only binding to the contract + StdInvariantTransactor // Write-only binding to the contract + StdInvariantFilterer // Log filterer for contract events +} + +// StdInvariantCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdInvariantCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdInvariantTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdInvariantTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdInvariantFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdInvariantFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdInvariantSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdInvariantSession struct { + Contract *StdInvariant // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdInvariantCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdInvariantCallerSession struct { + Contract *StdInvariantCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdInvariantTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdInvariantTransactorSession struct { + Contract *StdInvariantTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdInvariantRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdInvariantRaw struct { + Contract *StdInvariant // Generic contract binding to access the raw methods on +} + +// StdInvariantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdInvariantCallerRaw struct { + Contract *StdInvariantCaller // Generic read-only contract binding to access the raw methods on +} + +// StdInvariantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdInvariantTransactorRaw struct { + Contract *StdInvariantTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdInvariant creates a new instance of StdInvariant, bound to a specific deployed contract. +func NewStdInvariant(address common.Address, backend bind.ContractBackend) (*StdInvariant, error) { + contract, err := bindStdInvariant(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdInvariant{StdInvariantCaller: StdInvariantCaller{contract: contract}, StdInvariantTransactor: StdInvariantTransactor{contract: contract}, StdInvariantFilterer: StdInvariantFilterer{contract: contract}}, nil +} + +// NewStdInvariantCaller creates a new read-only instance of StdInvariant, bound to a specific deployed contract. +func NewStdInvariantCaller(address common.Address, caller bind.ContractCaller) (*StdInvariantCaller, error) { + contract, err := bindStdInvariant(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdInvariantCaller{contract: contract}, nil +} + +// NewStdInvariantTransactor creates a new write-only instance of StdInvariant, bound to a specific deployed contract. +func NewStdInvariantTransactor(address common.Address, transactor bind.ContractTransactor) (*StdInvariantTransactor, error) { + contract, err := bindStdInvariant(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdInvariantTransactor{contract: contract}, nil +} + +// NewStdInvariantFilterer creates a new log filterer instance of StdInvariant, bound to a specific deployed contract. +func NewStdInvariantFilterer(address common.Address, filterer bind.ContractFilterer) (*StdInvariantFilterer, error) { + contract, err := bindStdInvariant(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdInvariantFilterer{contract: contract}, nil +} + +// bindStdInvariant binds a generic wrapper to an already deployed contract. +func bindStdInvariant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdInvariantMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdInvariant *StdInvariantRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdInvariant.Contract.StdInvariantCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdInvariant *StdInvariantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdInvariant.Contract.StdInvariantTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdInvariant *StdInvariantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdInvariant.Contract.StdInvariantTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdInvariant *StdInvariantCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdInvariant.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdInvariant *StdInvariantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdInvariant.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdInvariant *StdInvariantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdInvariant.Contract.contract.Transact(opts, method, params...) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_StdInvariant *StdInvariantCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "excludeArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_StdInvariant *StdInvariantSession) ExcludeArtifacts() ([]string, error) { + return _StdInvariant.Contract.ExcludeArtifacts(&_StdInvariant.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_StdInvariant *StdInvariantCallerSession) ExcludeArtifacts() ([]string, error) { + return _StdInvariant.Contract.ExcludeArtifacts(&_StdInvariant.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_StdInvariant *StdInvariantCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "excludeContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_StdInvariant *StdInvariantSession) ExcludeContracts() ([]common.Address, error) { + return _StdInvariant.Contract.ExcludeContracts(&_StdInvariant.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_StdInvariant *StdInvariantCallerSession) ExcludeContracts() ([]common.Address, error) { + return _StdInvariant.Contract.ExcludeContracts(&_StdInvariant.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_StdInvariant *StdInvariantCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "excludeSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_StdInvariant *StdInvariantSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _StdInvariant.Contract.ExcludeSelectors(&_StdInvariant.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_StdInvariant *StdInvariantCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _StdInvariant.Contract.ExcludeSelectors(&_StdInvariant.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_StdInvariant *StdInvariantCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "excludeSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_StdInvariant *StdInvariantSession) ExcludeSenders() ([]common.Address, error) { + return _StdInvariant.Contract.ExcludeSenders(&_StdInvariant.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_StdInvariant *StdInvariantCallerSession) ExcludeSenders() ([]common.Address, error) { + return _StdInvariant.Contract.ExcludeSenders(&_StdInvariant.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_StdInvariant *StdInvariantCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetArtifactSelectors") + + if err != nil { + return *new([]StdInvariantFuzzArtifactSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector) + + return out0, err + +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_StdInvariant *StdInvariantSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _StdInvariant.Contract.TargetArtifactSelectors(&_StdInvariant.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_StdInvariant *StdInvariantCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _StdInvariant.Contract.TargetArtifactSelectors(&_StdInvariant.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_StdInvariant *StdInvariantCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_StdInvariant *StdInvariantSession) TargetArtifacts() ([]string, error) { + return _StdInvariant.Contract.TargetArtifacts(&_StdInvariant.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_StdInvariant *StdInvariantCallerSession) TargetArtifacts() ([]string, error) { + return _StdInvariant.Contract.TargetArtifacts(&_StdInvariant.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_StdInvariant *StdInvariantCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_StdInvariant *StdInvariantSession) TargetContracts() ([]common.Address, error) { + return _StdInvariant.Contract.TargetContracts(&_StdInvariant.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_StdInvariant *StdInvariantCallerSession) TargetContracts() ([]common.Address, error) { + return _StdInvariant.Contract.TargetContracts(&_StdInvariant.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_StdInvariant *StdInvariantCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetInterfaces") + + if err != nil { + return *new([]StdInvariantFuzzInterface), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface) + + return out0, err + +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_StdInvariant *StdInvariantSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _StdInvariant.Contract.TargetInterfaces(&_StdInvariant.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_StdInvariant *StdInvariantCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _StdInvariant.Contract.TargetInterfaces(&_StdInvariant.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_StdInvariant *StdInvariantCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_StdInvariant *StdInvariantSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _StdInvariant.Contract.TargetSelectors(&_StdInvariant.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_StdInvariant *StdInvariantCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _StdInvariant.Contract.TargetSelectors(&_StdInvariant.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_StdInvariant *StdInvariantCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _StdInvariant.contract.Call(opts, &out, "targetSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_StdInvariant *StdInvariantSession) TargetSenders() ([]common.Address, error) { + return _StdInvariant.Contract.TargetSenders(&_StdInvariant.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_StdInvariant *StdInvariantCallerSession) TargetSenders() ([]common.Address, error) { + return _StdInvariant.Contract.TargetSenders(&_StdInvariant.CallOpts) +} diff --git a/pkg/forge-std/stdjson.sol/stdjson.go b/pkg/forge-std/stdjson.sol/stdjson.go new file mode 100644 index 00000000..08407218 --- /dev/null +++ b/pkg/forge-std/stdjson.sol/stdjson.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdjson + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdJsonMetaData contains all meta data concerning the StdJson contract. +var StdJsonMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220fd118c1fcd3907eb874182e9003db5246bd358195bf6b0e544e419dc1d2826d964736f6c63430008070033", +} + +// StdJsonABI is the input ABI used to generate the binding from. +// Deprecated: Use StdJsonMetaData.ABI instead. +var StdJsonABI = StdJsonMetaData.ABI + +// StdJsonBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdJsonMetaData.Bin instead. +var StdJsonBin = StdJsonMetaData.Bin + +// DeployStdJson deploys a new Ethereum contract, binding an instance of StdJson to it. +func DeployStdJson(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdJson, error) { + parsed, err := StdJsonMetaData.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(StdJsonBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdJson{StdJsonCaller: StdJsonCaller{contract: contract}, StdJsonTransactor: StdJsonTransactor{contract: contract}, StdJsonFilterer: StdJsonFilterer{contract: contract}}, nil +} + +// StdJson is an auto generated Go binding around an Ethereum contract. +type StdJson struct { + StdJsonCaller // Read-only binding to the contract + StdJsonTransactor // Write-only binding to the contract + StdJsonFilterer // Log filterer for contract events +} + +// StdJsonCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdJsonCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdJsonTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdJsonTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdJsonFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdJsonFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdJsonSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdJsonSession struct { + Contract *StdJson // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdJsonCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdJsonCallerSession struct { + Contract *StdJsonCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdJsonTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdJsonTransactorSession struct { + Contract *StdJsonTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdJsonRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdJsonRaw struct { + Contract *StdJson // Generic contract binding to access the raw methods on +} + +// StdJsonCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdJsonCallerRaw struct { + Contract *StdJsonCaller // Generic read-only contract binding to access the raw methods on +} + +// StdJsonTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdJsonTransactorRaw struct { + Contract *StdJsonTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdJson creates a new instance of StdJson, bound to a specific deployed contract. +func NewStdJson(address common.Address, backend bind.ContractBackend) (*StdJson, error) { + contract, err := bindStdJson(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdJson{StdJsonCaller: StdJsonCaller{contract: contract}, StdJsonTransactor: StdJsonTransactor{contract: contract}, StdJsonFilterer: StdJsonFilterer{contract: contract}}, nil +} + +// NewStdJsonCaller creates a new read-only instance of StdJson, bound to a specific deployed contract. +func NewStdJsonCaller(address common.Address, caller bind.ContractCaller) (*StdJsonCaller, error) { + contract, err := bindStdJson(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdJsonCaller{contract: contract}, nil +} + +// NewStdJsonTransactor creates a new write-only instance of StdJson, bound to a specific deployed contract. +func NewStdJsonTransactor(address common.Address, transactor bind.ContractTransactor) (*StdJsonTransactor, error) { + contract, err := bindStdJson(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdJsonTransactor{contract: contract}, nil +} + +// NewStdJsonFilterer creates a new log filterer instance of StdJson, bound to a specific deployed contract. +func NewStdJsonFilterer(address common.Address, filterer bind.ContractFilterer) (*StdJsonFilterer, error) { + contract, err := bindStdJson(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdJsonFilterer{contract: contract}, nil +} + +// bindStdJson binds a generic wrapper to an already deployed contract. +func bindStdJson(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdJsonMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdJson *StdJsonRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdJson.Contract.StdJsonCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdJson *StdJsonRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdJson.Contract.StdJsonTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdJson *StdJsonRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdJson.Contract.StdJsonTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdJson *StdJsonCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdJson.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdJson *StdJsonTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdJson.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdJson *StdJsonTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdJson.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdmath.sol/stdmath.go b/pkg/forge-std/stdmath.sol/stdmath.go new file mode 100644 index 00000000..6a9dbf5f --- /dev/null +++ b/pkg/forge-std/stdmath.sol/stdmath.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdmath + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdMathMetaData contains all meta data concerning the StdMath contract. +var StdMathMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212202c9cb8336268ae69ebdb90faf9e4d33e5557f5ffbf651a355e34ae45b76c935a64736f6c63430008070033", +} + +// StdMathABI is the input ABI used to generate the binding from. +// Deprecated: Use StdMathMetaData.ABI instead. +var StdMathABI = StdMathMetaData.ABI + +// StdMathBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdMathMetaData.Bin instead. +var StdMathBin = StdMathMetaData.Bin + +// DeployStdMath deploys a new Ethereum contract, binding an instance of StdMath to it. +func DeployStdMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdMath, error) { + parsed, err := StdMathMetaData.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(StdMathBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdMath{StdMathCaller: StdMathCaller{contract: contract}, StdMathTransactor: StdMathTransactor{contract: contract}, StdMathFilterer: StdMathFilterer{contract: contract}}, nil +} + +// StdMath is an auto generated Go binding around an Ethereum contract. +type StdMath struct { + StdMathCaller // Read-only binding to the contract + StdMathTransactor // Write-only binding to the contract + StdMathFilterer // Log filterer for contract events +} + +// StdMathCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdMathCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdMathTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdMathTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdMathFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdMathSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdMathSession struct { + Contract *StdMath // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdMathCallerSession struct { + Contract *StdMathCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdMathTransactorSession struct { + Contract *StdMathTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdMathRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdMathRaw struct { + Contract *StdMath // Generic contract binding to access the raw methods on +} + +// StdMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdMathCallerRaw struct { + Contract *StdMathCaller // Generic read-only contract binding to access the raw methods on +} + +// StdMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdMathTransactorRaw struct { + Contract *StdMathTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdMath creates a new instance of StdMath, bound to a specific deployed contract. +func NewStdMath(address common.Address, backend bind.ContractBackend) (*StdMath, error) { + contract, err := bindStdMath(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdMath{StdMathCaller: StdMathCaller{contract: contract}, StdMathTransactor: StdMathTransactor{contract: contract}, StdMathFilterer: StdMathFilterer{contract: contract}}, nil +} + +// NewStdMathCaller creates a new read-only instance of StdMath, bound to a specific deployed contract. +func NewStdMathCaller(address common.Address, caller bind.ContractCaller) (*StdMathCaller, error) { + contract, err := bindStdMath(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdMathCaller{contract: contract}, nil +} + +// NewStdMathTransactor creates a new write-only instance of StdMath, bound to a specific deployed contract. +func NewStdMathTransactor(address common.Address, transactor bind.ContractTransactor) (*StdMathTransactor, error) { + contract, err := bindStdMath(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdMathTransactor{contract: contract}, nil +} + +// NewStdMathFilterer creates a new log filterer instance of StdMath, bound to a specific deployed contract. +func NewStdMathFilterer(address common.Address, filterer bind.ContractFilterer) (*StdMathFilterer, error) { + contract, err := bindStdMath(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdMathFilterer{contract: contract}, nil +} + +// bindStdMath binds a generic wrapper to an already deployed contract. +func bindStdMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdMathMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdMath *StdMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdMath.Contract.StdMathCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdMath *StdMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdMath.Contract.StdMathTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdMath *StdMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdMath.Contract.StdMathTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdMath *StdMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdMath.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdMath *StdMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdMath.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdMath *StdMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdMath.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdstorage.sol/stdstorage.go b/pkg/forge-std/stdstorage.sol/stdstorage.go new file mode 100644 index 00000000..43d4935e --- /dev/null +++ b/pkg/forge-std/stdstorage.sol/stdstorage.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdstorage + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdStorageMetaData contains all meta data concerning the StdStorage contract. +var StdStorageMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212200b6fb7014132ade9c41ca90b7cb0e09d7ce9bbcf96be59a54660031e1258522d64736f6c63430008070033", +} + +// StdStorageABI is the input ABI used to generate the binding from. +// Deprecated: Use StdStorageMetaData.ABI instead. +var StdStorageABI = StdStorageMetaData.ABI + +// StdStorageBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdStorageMetaData.Bin instead. +var StdStorageBin = StdStorageMetaData.Bin + +// DeployStdStorage deploys a new Ethereum contract, binding an instance of StdStorage to it. +func DeployStdStorage(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStorage, error) { + parsed, err := StdStorageMetaData.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(StdStorageBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdStorage{StdStorageCaller: StdStorageCaller{contract: contract}, StdStorageTransactor: StdStorageTransactor{contract: contract}, StdStorageFilterer: StdStorageFilterer{contract: contract}}, nil +} + +// StdStorage is an auto generated Go binding around an Ethereum contract. +type StdStorage struct { + StdStorageCaller // Read-only binding to the contract + StdStorageTransactor // Write-only binding to the contract + StdStorageFilterer // Log filterer for contract events +} + +// StdStorageCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdStorageCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdStorageTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdStorageFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdStorageSession struct { + Contract *StdStorage // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStorageCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdStorageCallerSession struct { + Contract *StdStorageCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdStorageTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdStorageTransactorSession struct { + Contract *StdStorageTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStorageRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdStorageRaw struct { + Contract *StdStorage // Generic contract binding to access the raw methods on +} + +// StdStorageCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdStorageCallerRaw struct { + Contract *StdStorageCaller // Generic read-only contract binding to access the raw methods on +} + +// StdStorageTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdStorageTransactorRaw struct { + Contract *StdStorageTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdStorage creates a new instance of StdStorage, bound to a specific deployed contract. +func NewStdStorage(address common.Address, backend bind.ContractBackend) (*StdStorage, error) { + contract, err := bindStdStorage(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdStorage{StdStorageCaller: StdStorageCaller{contract: contract}, StdStorageTransactor: StdStorageTransactor{contract: contract}, StdStorageFilterer: StdStorageFilterer{contract: contract}}, nil +} + +// NewStdStorageCaller creates a new read-only instance of StdStorage, bound to a specific deployed contract. +func NewStdStorageCaller(address common.Address, caller bind.ContractCaller) (*StdStorageCaller, error) { + contract, err := bindStdStorage(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdStorageCaller{contract: contract}, nil +} + +// NewStdStorageTransactor creates a new write-only instance of StdStorage, bound to a specific deployed contract. +func NewStdStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStorageTransactor, error) { + contract, err := bindStdStorage(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdStorageTransactor{contract: contract}, nil +} + +// NewStdStorageFilterer creates a new log filterer instance of StdStorage, bound to a specific deployed contract. +func NewStdStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStorageFilterer, error) { + contract, err := bindStdStorage(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdStorageFilterer{contract: contract}, nil +} + +// bindStdStorage binds a generic wrapper to an already deployed contract. +func bindStdStorage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdStorageMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStorage *StdStorageRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStorage.Contract.StdStorageCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStorage *StdStorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStorage.Contract.StdStorageTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStorage *StdStorageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStorage.Contract.StdStorageTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStorage *StdStorageCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStorage.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStorage *StdStorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStorage.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStorage *StdStorageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStorage.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdstorage.sol/stdstoragesafe.go b/pkg/forge-std/stdstorage.sol/stdstoragesafe.go new file mode 100644 index 00000000..cb144d78 --- /dev/null +++ b/pkg/forge-std/stdstorage.sol/stdstoragesafe.go @@ -0,0 +1,475 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdstorage + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdStorageSafeMetaData contains all meta data concerning the StdStorageSafe contract. +var StdStorageSafeMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes4\",\"name\":\"fsig\",\"type\":\"bytes4\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"keysHash\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slot\",\"type\":\"uint256\"}],\"name\":\"SlotFound\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slot\",\"type\":\"uint256\"}],\"name\":\"WARNING_UninitedSlot\",\"type\":\"event\"}]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220d00bd3f77bc95c5f63c719093a6d31da7bdf9c8d48a9ab8306cc99545a0bf89664736f6c63430008070033", +} + +// StdStorageSafeABI is the input ABI used to generate the binding from. +// Deprecated: Use StdStorageSafeMetaData.ABI instead. +var StdStorageSafeABI = StdStorageSafeMetaData.ABI + +// StdStorageSafeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdStorageSafeMetaData.Bin instead. +var StdStorageSafeBin = StdStorageSafeMetaData.Bin + +// DeployStdStorageSafe deploys a new Ethereum contract, binding an instance of StdStorageSafe to it. +func DeployStdStorageSafe(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStorageSafe, error) { + parsed, err := StdStorageSafeMetaData.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(StdStorageSafeBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdStorageSafe{StdStorageSafeCaller: StdStorageSafeCaller{contract: contract}, StdStorageSafeTransactor: StdStorageSafeTransactor{contract: contract}, StdStorageSafeFilterer: StdStorageSafeFilterer{contract: contract}}, nil +} + +// StdStorageSafe is an auto generated Go binding around an Ethereum contract. +type StdStorageSafe struct { + StdStorageSafeCaller // Read-only binding to the contract + StdStorageSafeTransactor // Write-only binding to the contract + StdStorageSafeFilterer // Log filterer for contract events +} + +// StdStorageSafeCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdStorageSafeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageSafeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdStorageSafeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdStorageSafeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStorageSafeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdStorageSafeSession struct { + Contract *StdStorageSafe // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStorageSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdStorageSafeCallerSession struct { + Contract *StdStorageSafeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdStorageSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdStorageSafeTransactorSession struct { + Contract *StdStorageSafeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStorageSafeRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdStorageSafeRaw struct { + Contract *StdStorageSafe // Generic contract binding to access the raw methods on +} + +// StdStorageSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdStorageSafeCallerRaw struct { + Contract *StdStorageSafeCaller // Generic read-only contract binding to access the raw methods on +} + +// StdStorageSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdStorageSafeTransactorRaw struct { + Contract *StdStorageSafeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdStorageSafe creates a new instance of StdStorageSafe, bound to a specific deployed contract. +func NewStdStorageSafe(address common.Address, backend bind.ContractBackend) (*StdStorageSafe, error) { + contract, err := bindStdStorageSafe(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdStorageSafe{StdStorageSafeCaller: StdStorageSafeCaller{contract: contract}, StdStorageSafeTransactor: StdStorageSafeTransactor{contract: contract}, StdStorageSafeFilterer: StdStorageSafeFilterer{contract: contract}}, nil +} + +// NewStdStorageSafeCaller creates a new read-only instance of StdStorageSafe, bound to a specific deployed contract. +func NewStdStorageSafeCaller(address common.Address, caller bind.ContractCaller) (*StdStorageSafeCaller, error) { + contract, err := bindStdStorageSafe(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdStorageSafeCaller{contract: contract}, nil +} + +// NewStdStorageSafeTransactor creates a new write-only instance of StdStorageSafe, bound to a specific deployed contract. +func NewStdStorageSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStorageSafeTransactor, error) { + contract, err := bindStdStorageSafe(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdStorageSafeTransactor{contract: contract}, nil +} + +// NewStdStorageSafeFilterer creates a new log filterer instance of StdStorageSafe, bound to a specific deployed contract. +func NewStdStorageSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStorageSafeFilterer, error) { + contract, err := bindStdStorageSafe(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdStorageSafeFilterer{contract: contract}, nil +} + +// bindStdStorageSafe binds a generic wrapper to an already deployed contract. +func bindStdStorageSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdStorageSafeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStorageSafe *StdStorageSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStorageSafe.Contract.StdStorageSafeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStorageSafe *StdStorageSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStorageSafe.Contract.StdStorageSafeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStorageSafe *StdStorageSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStorageSafe.Contract.StdStorageSafeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStorageSafe *StdStorageSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStorageSafe.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStorageSafe *StdStorageSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStorageSafe.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStorageSafe *StdStorageSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStorageSafe.Contract.contract.Transact(opts, method, params...) +} + +// StdStorageSafeSlotFoundIterator is returned from FilterSlotFound and is used to iterate over the raw logs and unpacked data for SlotFound events raised by the StdStorageSafe contract. +type StdStorageSafeSlotFoundIterator struct { + Event *StdStorageSafeSlotFound // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdStorageSafeSlotFoundIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdStorageSafeSlotFound) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdStorageSafeSlotFound) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdStorageSafeSlotFoundIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdStorageSafeSlotFoundIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdStorageSafeSlotFound represents a SlotFound event raised by the StdStorageSafe contract. +type StdStorageSafeSlotFound struct { + Who common.Address + Fsig [4]byte + KeysHash [32]byte + Slot *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSlotFound is a free log retrieval operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed. +// +// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) FilterSlotFound(opts *bind.FilterOpts) (*StdStorageSafeSlotFoundIterator, error) { + + logs, sub, err := _StdStorageSafe.contract.FilterLogs(opts, "SlotFound") + if err != nil { + return nil, err + } + return &StdStorageSafeSlotFoundIterator{contract: _StdStorageSafe.contract, event: "SlotFound", logs: logs, sub: sub}, nil +} + +// WatchSlotFound is a free log subscription operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed. +// +// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) WatchSlotFound(opts *bind.WatchOpts, sink chan<- *StdStorageSafeSlotFound) (event.Subscription, error) { + + logs, sub, err := _StdStorageSafe.contract.WatchLogs(opts, "SlotFound") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdStorageSafeSlotFound) + if err := _StdStorageSafe.contract.UnpackLog(event, "SlotFound", 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 +} + +// ParseSlotFound is a log parse operation binding the contract event 0x9c9555b1e3102e3cf48f427d79cb678f5d9bd1ed0ad574389461e255f95170ed. +// +// Solidity: event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) ParseSlotFound(log types.Log) (*StdStorageSafeSlotFound, error) { + event := new(StdStorageSafeSlotFound) + if err := _StdStorageSafe.contract.UnpackLog(event, "SlotFound", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// StdStorageSafeWARNINGUninitedSlotIterator is returned from FilterWARNINGUninitedSlot and is used to iterate over the raw logs and unpacked data for WARNINGUninitedSlot events raised by the StdStorageSafe contract. +type StdStorageSafeWARNINGUninitedSlotIterator struct { + Event *StdStorageSafeWARNINGUninitedSlot // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StdStorageSafeWARNINGUninitedSlotIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StdStorageSafeWARNINGUninitedSlot) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StdStorageSafeWARNINGUninitedSlot) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StdStorageSafeWARNINGUninitedSlotIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StdStorageSafeWARNINGUninitedSlotIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StdStorageSafeWARNINGUninitedSlot represents a WARNINGUninitedSlot event raised by the StdStorageSafe contract. +type StdStorageSafeWARNINGUninitedSlot struct { + Who common.Address + Slot *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWARNINGUninitedSlot is a free log retrieval operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5. +// +// Solidity: event WARNING_UninitedSlot(address who, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) FilterWARNINGUninitedSlot(opts *bind.FilterOpts) (*StdStorageSafeWARNINGUninitedSlotIterator, error) { + + logs, sub, err := _StdStorageSafe.contract.FilterLogs(opts, "WARNING_UninitedSlot") + if err != nil { + return nil, err + } + return &StdStorageSafeWARNINGUninitedSlotIterator{contract: _StdStorageSafe.contract, event: "WARNING_UninitedSlot", logs: logs, sub: sub}, nil +} + +// WatchWARNINGUninitedSlot is a free log subscription operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5. +// +// Solidity: event WARNING_UninitedSlot(address who, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) WatchWARNINGUninitedSlot(opts *bind.WatchOpts, sink chan<- *StdStorageSafeWARNINGUninitedSlot) (event.Subscription, error) { + + logs, sub, err := _StdStorageSafe.contract.WatchLogs(opts, "WARNING_UninitedSlot") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StdStorageSafeWARNINGUninitedSlot) + if err := _StdStorageSafe.contract.UnpackLog(event, "WARNING_UninitedSlot", 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 +} + +// ParseWARNINGUninitedSlot is a log parse operation binding the contract event 0x080fc4a96620c4462e705b23f346413fe3796bb63c6f8d8591baec0e231577a5. +// +// Solidity: event WARNING_UninitedSlot(address who, uint256 slot) +func (_StdStorageSafe *StdStorageSafeFilterer) ParseWARNINGUninitedSlot(log types.Log) (*StdStorageSafeWARNINGUninitedSlot, error) { + event := new(StdStorageSafeWARNINGUninitedSlot) + if err := _StdStorageSafe.contract.UnpackLog(event, "WARNING_UninitedSlot", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/stdstyle.sol/stdstyle.go b/pkg/forge-std/stdstyle.sol/stdstyle.go new file mode 100644 index 00000000..62f50c57 --- /dev/null +++ b/pkg/forge-std/stdstyle.sol/stdstyle.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdstyle + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdStyleMetaData contains all meta data concerning the StdStyle contract. +var StdStyleMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea264697066735822122076e9da14a2764d00eaf674a9ed2ffca5f85c03aafbeb496e4b22be2fbc5f8c8e64736f6c63430008070033", +} + +// StdStyleABI is the input ABI used to generate the binding from. +// Deprecated: Use StdStyleMetaData.ABI instead. +var StdStyleABI = StdStyleMetaData.ABI + +// StdStyleBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdStyleMetaData.Bin instead. +var StdStyleBin = StdStyleMetaData.Bin + +// DeployStdStyle deploys a new Ethereum contract, binding an instance of StdStyle to it. +func DeployStdStyle(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdStyle, error) { + parsed, err := StdStyleMetaData.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(StdStyleBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdStyle{StdStyleCaller: StdStyleCaller{contract: contract}, StdStyleTransactor: StdStyleTransactor{contract: contract}, StdStyleFilterer: StdStyleFilterer{contract: contract}}, nil +} + +// StdStyle is an auto generated Go binding around an Ethereum contract. +type StdStyle struct { + StdStyleCaller // Read-only binding to the contract + StdStyleTransactor // Write-only binding to the contract + StdStyleFilterer // Log filterer for contract events +} + +// StdStyleCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdStyleCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStyleTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdStyleTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStyleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdStyleFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdStyleSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdStyleSession struct { + Contract *StdStyle // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStyleCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdStyleCallerSession struct { + Contract *StdStyleCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdStyleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdStyleTransactorSession struct { + Contract *StdStyleTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdStyleRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdStyleRaw struct { + Contract *StdStyle // Generic contract binding to access the raw methods on +} + +// StdStyleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdStyleCallerRaw struct { + Contract *StdStyleCaller // Generic read-only contract binding to access the raw methods on +} + +// StdStyleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdStyleTransactorRaw struct { + Contract *StdStyleTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdStyle creates a new instance of StdStyle, bound to a specific deployed contract. +func NewStdStyle(address common.Address, backend bind.ContractBackend) (*StdStyle, error) { + contract, err := bindStdStyle(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdStyle{StdStyleCaller: StdStyleCaller{contract: contract}, StdStyleTransactor: StdStyleTransactor{contract: contract}, StdStyleFilterer: StdStyleFilterer{contract: contract}}, nil +} + +// NewStdStyleCaller creates a new read-only instance of StdStyle, bound to a specific deployed contract. +func NewStdStyleCaller(address common.Address, caller bind.ContractCaller) (*StdStyleCaller, error) { + contract, err := bindStdStyle(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdStyleCaller{contract: contract}, nil +} + +// NewStdStyleTransactor creates a new write-only instance of StdStyle, bound to a specific deployed contract. +func NewStdStyleTransactor(address common.Address, transactor bind.ContractTransactor) (*StdStyleTransactor, error) { + contract, err := bindStdStyle(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdStyleTransactor{contract: contract}, nil +} + +// NewStdStyleFilterer creates a new log filterer instance of StdStyle, bound to a specific deployed contract. +func NewStdStyleFilterer(address common.Address, filterer bind.ContractFilterer) (*StdStyleFilterer, error) { + contract, err := bindStdStyle(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdStyleFilterer{contract: contract}, nil +} + +// bindStdStyle binds a generic wrapper to an already deployed contract. +func bindStdStyle(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdStyleMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStyle *StdStyleRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStyle.Contract.StdStyleCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStyle *StdStyleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStyle.Contract.StdStyleTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStyle *StdStyleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStyle.Contract.StdStyleTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdStyle *StdStyleCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdStyle.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdStyle *StdStyleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdStyle.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdStyle *StdStyleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdStyle.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdtoml.sol/stdtoml.go b/pkg/forge-std/stdtoml.sol/stdtoml.go new file mode 100644 index 00000000..fa1a104a --- /dev/null +++ b/pkg/forge-std/stdtoml.sol/stdtoml.go @@ -0,0 +1,203 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdtoml + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdTomlMetaData contains all meta data concerning the StdToml contract. +var StdTomlMetaData = &bind.MetaData{ + ABI: "[]", + Bin: "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220e25044dac3c36497036f0280f9b889943144979220629a5dccb0befcba234d5964736f6c63430008070033", +} + +// StdTomlABI is the input ABI used to generate the binding from. +// Deprecated: Use StdTomlMetaData.ABI instead. +var StdTomlABI = StdTomlMetaData.ABI + +// StdTomlBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use StdTomlMetaData.Bin instead. +var StdTomlBin = StdTomlMetaData.Bin + +// DeployStdToml deploys a new Ethereum contract, binding an instance of StdToml to it. +func DeployStdToml(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StdToml, error) { + parsed, err := StdTomlMetaData.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(StdTomlBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &StdToml{StdTomlCaller: StdTomlCaller{contract: contract}, StdTomlTransactor: StdTomlTransactor{contract: contract}, StdTomlFilterer: StdTomlFilterer{contract: contract}}, nil +} + +// StdToml is an auto generated Go binding around an Ethereum contract. +type StdToml struct { + StdTomlCaller // Read-only binding to the contract + StdTomlTransactor // Write-only binding to the contract + StdTomlFilterer // Log filterer for contract events +} + +// StdTomlCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdTomlCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdTomlTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdTomlTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdTomlFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdTomlFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdTomlSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdTomlSession struct { + Contract *StdToml // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdTomlCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdTomlCallerSession struct { + Contract *StdTomlCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdTomlTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdTomlTransactorSession struct { + Contract *StdTomlTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdTomlRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdTomlRaw struct { + Contract *StdToml // Generic contract binding to access the raw methods on +} + +// StdTomlCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdTomlCallerRaw struct { + Contract *StdTomlCaller // Generic read-only contract binding to access the raw methods on +} + +// StdTomlTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdTomlTransactorRaw struct { + Contract *StdTomlTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdToml creates a new instance of StdToml, bound to a specific deployed contract. +func NewStdToml(address common.Address, backend bind.ContractBackend) (*StdToml, error) { + contract, err := bindStdToml(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdToml{StdTomlCaller: StdTomlCaller{contract: contract}, StdTomlTransactor: StdTomlTransactor{contract: contract}, StdTomlFilterer: StdTomlFilterer{contract: contract}}, nil +} + +// NewStdTomlCaller creates a new read-only instance of StdToml, bound to a specific deployed contract. +func NewStdTomlCaller(address common.Address, caller bind.ContractCaller) (*StdTomlCaller, error) { + contract, err := bindStdToml(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdTomlCaller{contract: contract}, nil +} + +// NewStdTomlTransactor creates a new write-only instance of StdToml, bound to a specific deployed contract. +func NewStdTomlTransactor(address common.Address, transactor bind.ContractTransactor) (*StdTomlTransactor, error) { + contract, err := bindStdToml(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdTomlTransactor{contract: contract}, nil +} + +// NewStdTomlFilterer creates a new log filterer instance of StdToml, bound to a specific deployed contract. +func NewStdTomlFilterer(address common.Address, filterer bind.ContractFilterer) (*StdTomlFilterer, error) { + contract, err := bindStdToml(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdTomlFilterer{contract: contract}, nil +} + +// bindStdToml binds a generic wrapper to an already deployed contract. +func bindStdToml(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdTomlMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdToml *StdTomlRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdToml.Contract.StdTomlCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdToml *StdTomlRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdToml.Contract.StdTomlTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdToml *StdTomlRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdToml.Contract.StdTomlTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdToml *StdTomlCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdToml.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdToml *StdTomlTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdToml.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdToml *StdTomlTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdToml.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/stdutils.sol/stdutils.go b/pkg/forge-std/stdutils.sol/stdutils.go new file mode 100644 index 00000000..88d73846 --- /dev/null +++ b/pkg/forge-std/stdutils.sol/stdutils.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package stdutils + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdUtilsMetaData contains all meta data concerning the StdUtils contract. +var StdUtilsMetaData = &bind.MetaData{ + ABI: "[]", +} + +// StdUtilsABI is the input ABI used to generate the binding from. +// Deprecated: Use StdUtilsMetaData.ABI instead. +var StdUtilsABI = StdUtilsMetaData.ABI + +// StdUtils is an auto generated Go binding around an Ethereum contract. +type StdUtils struct { + StdUtilsCaller // Read-only binding to the contract + StdUtilsTransactor // Write-only binding to the contract + StdUtilsFilterer // Log filterer for contract events +} + +// StdUtilsCaller is an auto generated read-only Go binding around an Ethereum contract. +type StdUtilsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdUtilsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StdUtilsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdUtilsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StdUtilsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StdUtilsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StdUtilsSession struct { + Contract *StdUtils // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdUtilsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StdUtilsCallerSession struct { + Contract *StdUtilsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StdUtilsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StdUtilsTransactorSession struct { + Contract *StdUtilsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StdUtilsRaw is an auto generated low-level Go binding around an Ethereum contract. +type StdUtilsRaw struct { + Contract *StdUtils // Generic contract binding to access the raw methods on +} + +// StdUtilsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StdUtilsCallerRaw struct { + Contract *StdUtilsCaller // Generic read-only contract binding to access the raw methods on +} + +// StdUtilsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StdUtilsTransactorRaw struct { + Contract *StdUtilsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStdUtils creates a new instance of StdUtils, bound to a specific deployed contract. +func NewStdUtils(address common.Address, backend bind.ContractBackend) (*StdUtils, error) { + contract, err := bindStdUtils(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StdUtils{StdUtilsCaller: StdUtilsCaller{contract: contract}, StdUtilsTransactor: StdUtilsTransactor{contract: contract}, StdUtilsFilterer: StdUtilsFilterer{contract: contract}}, nil +} + +// NewStdUtilsCaller creates a new read-only instance of StdUtils, bound to a specific deployed contract. +func NewStdUtilsCaller(address common.Address, caller bind.ContractCaller) (*StdUtilsCaller, error) { + contract, err := bindStdUtils(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StdUtilsCaller{contract: contract}, nil +} + +// NewStdUtilsTransactor creates a new write-only instance of StdUtils, bound to a specific deployed contract. +func NewStdUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*StdUtilsTransactor, error) { + contract, err := bindStdUtils(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StdUtilsTransactor{contract: contract}, nil +} + +// NewStdUtilsFilterer creates a new log filterer instance of StdUtils, bound to a specific deployed contract. +func NewStdUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*StdUtilsFilterer, error) { + contract, err := bindStdUtils(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StdUtilsFilterer{contract: contract}, nil +} + +// bindStdUtils binds a generic wrapper to an already deployed contract. +func bindStdUtils(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := StdUtilsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdUtils *StdUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdUtils.Contract.StdUtilsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdUtils *StdUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdUtils.Contract.StdUtilsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdUtils *StdUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdUtils.Contract.StdUtilsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StdUtils *StdUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _StdUtils.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StdUtils *StdUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StdUtils.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StdUtils *StdUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StdUtils.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/forge-std/test.sol/test.go b/pkg/forge-std/test.sol/test.go new file mode 100644 index 00000000..798f4e1f --- /dev/null +++ b/pkg/forge-std/test.sol/test.go @@ -0,0 +1,3532 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package test + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdInvariantFuzzArtifactSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzArtifactSelector struct { + Artifact string + Selectors [][4]byte +} + +// StdInvariantFuzzInterface is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzInterface struct { + Addr common.Address + Artifacts []string +} + +// StdInvariantFuzzSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzSelector struct { + Addr common.Address + Selectors [][4]byte +} + +// TestMetaData contains all meta data concerning the Test contract. +var TestMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// TestABI is the input ABI used to generate the binding from. +// Deprecated: Use TestMetaData.ABI instead. +var TestABI = TestMetaData.ABI + +// Test is an auto generated Go binding around an Ethereum contract. +type Test struct { + TestCaller // Read-only binding to the contract + TestTransactor // Write-only binding to the contract + TestFilterer // Log filterer for contract events +} + +// TestCaller is an auto generated read-only Go binding around an Ethereum contract. +type TestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type TestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type TestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type TestSession struct { + Contract *Test // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type TestCallerSession struct { + Contract *TestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// TestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type TestTransactorSession struct { + Contract *TestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TestRaw is an auto generated low-level Go binding around an Ethereum contract. +type TestRaw struct { + Contract *Test // Generic contract binding to access the raw methods on +} + +// TestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type TestCallerRaw struct { + Contract *TestCaller // Generic read-only contract binding to access the raw methods on +} + +// TestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type TestTransactorRaw struct { + Contract *TestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewTest creates a new instance of Test, bound to a specific deployed contract. +func NewTest(address common.Address, backend bind.ContractBackend) (*Test, error) { + contract, err := bindTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Test{TestCaller: TestCaller{contract: contract}, TestTransactor: TestTransactor{contract: contract}, TestFilterer: TestFilterer{contract: contract}}, nil +} + +// NewTestCaller creates a new read-only instance of Test, bound to a specific deployed contract. +func NewTestCaller(address common.Address, caller bind.ContractCaller) (*TestCaller, error) { + contract, err := bindTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &TestCaller{contract: contract}, nil +} + +// NewTestTransactor creates a new write-only instance of Test, bound to a specific deployed contract. +func NewTestTransactor(address common.Address, transactor bind.ContractTransactor) (*TestTransactor, error) { + contract, err := bindTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &TestTransactor{contract: contract}, nil +} + +// NewTestFilterer creates a new log filterer instance of Test, bound to a specific deployed contract. +func NewTestFilterer(address common.Address, filterer bind.ContractFilterer) (*TestFilterer, error) { + contract, err := bindTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &TestFilterer{contract: contract}, nil +} + +// bindTest binds a generic wrapper to an already deployed contract. +func bindTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := TestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Test *TestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Test.Contract.TestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Test *TestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Test.Contract.TestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Test *TestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Test.Contract.TestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Test *TestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Test.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Test *TestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Test.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Test *TestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Test.Contract.contract.Transact(opts, method, params...) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_Test *TestCaller) ISTEST(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "IS_TEST") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_Test *TestSession) ISTEST() (bool, error) { + return _Test.Contract.ISTEST(&_Test.CallOpts) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_Test *TestCallerSession) ISTEST() (bool, error) { + return _Test.Contract.ISTEST(&_Test.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_Test *TestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "excludeArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_Test *TestSession) ExcludeArtifacts() ([]string, error) { + return _Test.Contract.ExcludeArtifacts(&_Test.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_Test *TestCallerSession) ExcludeArtifacts() ([]string, error) { + return _Test.Contract.ExcludeArtifacts(&_Test.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_Test *TestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "excludeContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_Test *TestSession) ExcludeContracts() ([]common.Address, error) { + return _Test.Contract.ExcludeContracts(&_Test.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_Test *TestCallerSession) ExcludeContracts() ([]common.Address, error) { + return _Test.Contract.ExcludeContracts(&_Test.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_Test *TestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "excludeSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_Test *TestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _Test.Contract.ExcludeSelectors(&_Test.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_Test *TestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _Test.Contract.ExcludeSelectors(&_Test.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_Test *TestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "excludeSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_Test *TestSession) ExcludeSenders() ([]common.Address, error) { + return _Test.Contract.ExcludeSenders(&_Test.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_Test *TestCallerSession) ExcludeSenders() ([]common.Address, error) { + return _Test.Contract.ExcludeSenders(&_Test.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_Test *TestCaller) Failed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "failed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_Test *TestSession) Failed() (bool, error) { + return _Test.Contract.Failed(&_Test.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_Test *TestCallerSession) Failed() (bool, error) { + return _Test.Contract.Failed(&_Test.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_Test *TestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetArtifactSelectors") + + if err != nil { + return *new([]StdInvariantFuzzArtifactSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector) + + return out0, err + +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_Test *TestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _Test.Contract.TargetArtifactSelectors(&_Test.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_Test *TestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _Test.Contract.TargetArtifactSelectors(&_Test.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_Test *TestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_Test *TestSession) TargetArtifacts() ([]string, error) { + return _Test.Contract.TargetArtifacts(&_Test.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_Test *TestCallerSession) TargetArtifacts() ([]string, error) { + return _Test.Contract.TargetArtifacts(&_Test.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_Test *TestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_Test *TestSession) TargetContracts() ([]common.Address, error) { + return _Test.Contract.TargetContracts(&_Test.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_Test *TestCallerSession) TargetContracts() ([]common.Address, error) { + return _Test.Contract.TargetContracts(&_Test.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_Test *TestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetInterfaces") + + if err != nil { + return *new([]StdInvariantFuzzInterface), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface) + + return out0, err + +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_Test *TestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _Test.Contract.TargetInterfaces(&_Test.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_Test *TestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _Test.Contract.TargetInterfaces(&_Test.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_Test *TestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_Test *TestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _Test.Contract.TargetSelectors(&_Test.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_Test *TestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _Test.Contract.TargetSelectors(&_Test.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_Test *TestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _Test.contract.Call(opts, &out, "targetSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_Test *TestSession) TargetSenders() ([]common.Address, error) { + return _Test.Contract.TargetSenders(&_Test.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_Test *TestCallerSession) TargetSenders() ([]common.Address, error) { + return _Test.Contract.TargetSenders(&_Test.CallOpts) +} + +// TestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the Test contract. +type TestLogIterator struct { + Event *TestLog // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLog represents a Log event raised by the Test contract. +type TestLog struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_Test *TestFilterer) FilterLog(opts *bind.FilterOpts) (*TestLogIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log") + if err != nil { + return nil, err + } + return &TestLogIterator{contract: _Test.contract, event: "log", logs: logs, sub: sub}, nil +} + +// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_Test *TestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *TestLog) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLog) + if err := _Test.contract.UnpackLog(event, "log", 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 +} + +// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_Test *TestFilterer) ParseLog(log types.Log) (*TestLog, error) { + event := new(TestLog) + if err := _Test.contract.UnpackLog(event, "log", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the Test contract. +type TestLogAddressIterator struct { + Event *TestLogAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogAddress represents a LogAddress event raised by the Test contract. +type TestLogAddress struct { + Arg0 common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_Test *TestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*TestLogAddressIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_address") + if err != nil { + return nil, err + } + return &TestLogAddressIterator{contract: _Test.contract, event: "log_address", logs: logs, sub: sub}, nil +} + +// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_Test *TestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *TestLogAddress) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogAddress) + if err := _Test.contract.UnpackLog(event, "log_address", 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 +} + +// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_Test *TestFilterer) ParseLogAddress(log types.Log) (*TestLogAddress, error) { + event := new(TestLogAddress) + if err := _Test.contract.UnpackLog(event, "log_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the Test contract. +type TestLogArrayIterator struct { + Event *TestLogArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogArray represents a LogArray event raised by the Test contract. +type TestLogArray struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_Test *TestFilterer) FilterLogArray(opts *bind.FilterOpts) (*TestLogArrayIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_array") + if err != nil { + return nil, err + } + return &TestLogArrayIterator{contract: _Test.contract, event: "log_array", logs: logs, sub: sub}, nil +} + +// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_Test *TestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *TestLogArray) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogArray) + if err := _Test.contract.UnpackLog(event, "log_array", 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 +} + +// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_Test *TestFilterer) ParseLogArray(log types.Log) (*TestLogArray, error) { + event := new(TestLogArray) + if err := _Test.contract.UnpackLog(event, "log_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the Test contract. +type TestLogArray0Iterator struct { + Event *TestLogArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogArray0 represents a LogArray0 event raised by the Test contract. +type TestLogArray0 struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_Test *TestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*TestLogArray0Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return &TestLogArray0Iterator{contract: _Test.contract, event: "log_array0", logs: logs, sub: sub}, nil +} + +// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_Test *TestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *TestLogArray0) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogArray0) + if err := _Test.contract.UnpackLog(event, "log_array0", 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 +} + +// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_Test *TestFilterer) ParseLogArray0(log types.Log) (*TestLogArray0, error) { + event := new(TestLogArray0) + if err := _Test.contract.UnpackLog(event, "log_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the Test contract. +type TestLogArray1Iterator struct { + Event *TestLogArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogArray1 represents a LogArray1 event raised by the Test contract. +type TestLogArray1 struct { + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_Test *TestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*TestLogArray1Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return &TestLogArray1Iterator{contract: _Test.contract, event: "log_array1", logs: logs, sub: sub}, nil +} + +// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_Test *TestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *TestLogArray1) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogArray1) + if err := _Test.contract.UnpackLog(event, "log_array1", 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 +} + +// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_Test *TestFilterer) ParseLogArray1(log types.Log) (*TestLogArray1, error) { + event := new(TestLogArray1) + if err := _Test.contract.UnpackLog(event, "log_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the Test contract. +type TestLogBytesIterator struct { + Event *TestLogBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogBytes represents a LogBytes event raised by the Test contract. +type TestLogBytes struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_Test *TestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*TestLogBytesIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return &TestLogBytesIterator{contract: _Test.contract, event: "log_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_Test *TestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *TestLogBytes) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogBytes) + if err := _Test.contract.UnpackLog(event, "log_bytes", 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 +} + +// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_Test *TestFilterer) ParseLogBytes(log types.Log) (*TestLogBytes, error) { + event := new(TestLogBytes) + if err := _Test.contract.UnpackLog(event, "log_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the Test contract. +type TestLogBytes32Iterator struct { + Event *TestLogBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogBytes32 represents a LogBytes32 event raised by the Test contract. +type TestLogBytes32 struct { + Arg0 [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_Test *TestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*TestLogBytes32Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return &TestLogBytes32Iterator{contract: _Test.contract, event: "log_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_Test *TestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *TestLogBytes32) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogBytes32) + if err := _Test.contract.UnpackLog(event, "log_bytes32", 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 +} + +// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_Test *TestFilterer) ParseLogBytes32(log types.Log) (*TestLogBytes32, error) { + event := new(TestLogBytes32) + if err := _Test.contract.UnpackLog(event, "log_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the Test contract. +type TestLogIntIterator struct { + Event *TestLogInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogInt represents a LogInt event raised by the Test contract. +type TestLogInt struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_Test *TestFilterer) FilterLogInt(opts *bind.FilterOpts) (*TestLogIntIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_int") + if err != nil { + return nil, err + } + return &TestLogIntIterator{contract: _Test.contract, event: "log_int", logs: logs, sub: sub}, nil +} + +// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_Test *TestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *TestLogInt) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogInt) + if err := _Test.contract.UnpackLog(event, "log_int", 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 +} + +// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_Test *TestFilterer) ParseLogInt(log types.Log) (*TestLogInt, error) { + event := new(TestLogInt) + if err := _Test.contract.UnpackLog(event, "log_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the Test contract. +type TestLogNamedAddressIterator struct { + Event *TestLogNamedAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedAddress represents a LogNamedAddress event raised by the Test contract. +type TestLogNamedAddress struct { + Key string + Val common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_Test *TestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*TestLogNamedAddressIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return &TestLogNamedAddressIterator{contract: _Test.contract, event: "log_named_address", logs: logs, sub: sub}, nil +} + +// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_Test *TestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *TestLogNamedAddress) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedAddress) + if err := _Test.contract.UnpackLog(event, "log_named_address", 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 +} + +// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_Test *TestFilterer) ParseLogNamedAddress(log types.Log) (*TestLogNamedAddress, error) { + event := new(TestLogNamedAddress) + if err := _Test.contract.UnpackLog(event, "log_named_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the Test contract. +type TestLogNamedArrayIterator struct { + Event *TestLogNamedArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedArray represents a LogNamedArray event raised by the Test contract. +type TestLogNamedArray struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_Test *TestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*TestLogNamedArrayIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return &TestLogNamedArrayIterator{contract: _Test.contract, event: "log_named_array", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_Test *TestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedArray) + if err := _Test.contract.UnpackLog(event, "log_named_array", 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 +} + +// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_Test *TestFilterer) ParseLogNamedArray(log types.Log) (*TestLogNamedArray, error) { + event := new(TestLogNamedArray) + if err := _Test.contract.UnpackLog(event, "log_named_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the Test contract. +type TestLogNamedArray0Iterator struct { + Event *TestLogNamedArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedArray0 represents a LogNamedArray0 event raised by the Test contract. +type TestLogNamedArray0 struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_Test *TestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*TestLogNamedArray0Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return &TestLogNamedArray0Iterator{contract: _Test.contract, event: "log_named_array0", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_Test *TestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray0) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedArray0) + if err := _Test.contract.UnpackLog(event, "log_named_array0", 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 +} + +// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_Test *TestFilterer) ParseLogNamedArray0(log types.Log) (*TestLogNamedArray0, error) { + event := new(TestLogNamedArray0) + if err := _Test.contract.UnpackLog(event, "log_named_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the Test contract. +type TestLogNamedArray1Iterator struct { + Event *TestLogNamedArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedArray1 represents a LogNamedArray1 event raised by the Test contract. +type TestLogNamedArray1 struct { + Key string + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_Test *TestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*TestLogNamedArray1Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return &TestLogNamedArray1Iterator{contract: _Test.contract, event: "log_named_array1", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_Test *TestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *TestLogNamedArray1) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedArray1) + if err := _Test.contract.UnpackLog(event, "log_named_array1", 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 +} + +// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_Test *TestFilterer) ParseLogNamedArray1(log types.Log) (*TestLogNamedArray1, error) { + event := new(TestLogNamedArray1) + if err := _Test.contract.UnpackLog(event, "log_named_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the Test contract. +type TestLogNamedBytesIterator struct { + Event *TestLogNamedBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedBytes represents a LogNamedBytes event raised by the Test contract. +type TestLogNamedBytes struct { + Key string + Val []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_Test *TestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*TestLogNamedBytesIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return &TestLogNamedBytesIterator{contract: _Test.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_Test *TestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *TestLogNamedBytes) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedBytes) + if err := _Test.contract.UnpackLog(event, "log_named_bytes", 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 +} + +// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_Test *TestFilterer) ParseLogNamedBytes(log types.Log) (*TestLogNamedBytes, error) { + event := new(TestLogNamedBytes) + if err := _Test.contract.UnpackLog(event, "log_named_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the Test contract. +type TestLogNamedBytes32Iterator struct { + Event *TestLogNamedBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedBytes32 represents a LogNamedBytes32 event raised by the Test contract. +type TestLogNamedBytes32 struct { + Key string + Val [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_Test *TestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*TestLogNamedBytes32Iterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return &TestLogNamedBytes32Iterator{contract: _Test.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_Test *TestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *TestLogNamedBytes32) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedBytes32) + if err := _Test.contract.UnpackLog(event, "log_named_bytes32", 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 +} + +// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_Test *TestFilterer) ParseLogNamedBytes32(log types.Log) (*TestLogNamedBytes32, error) { + event := new(TestLogNamedBytes32) + if err := _Test.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the Test contract. +type TestLogNamedDecimalIntIterator struct { + Event *TestLogNamedDecimalInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedDecimalIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedDecimalIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedDecimalIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the Test contract. +type TestLogNamedDecimalInt struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_Test *TestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*TestLogNamedDecimalIntIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return &TestLogNamedDecimalIntIterator{contract: _Test.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_Test *TestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *TestLogNamedDecimalInt) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedDecimalInt) + if err := _Test.contract.UnpackLog(event, "log_named_decimal_int", 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 +} + +// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_Test *TestFilterer) ParseLogNamedDecimalInt(log types.Log) (*TestLogNamedDecimalInt, error) { + event := new(TestLogNamedDecimalInt) + if err := _Test.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the Test contract. +type TestLogNamedDecimalUintIterator struct { + Event *TestLogNamedDecimalUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedDecimalUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedDecimalUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedDecimalUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the Test contract. +type TestLogNamedDecimalUint struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_Test *TestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*TestLogNamedDecimalUintIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return &TestLogNamedDecimalUintIterator{contract: _Test.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_Test *TestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *TestLogNamedDecimalUint) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedDecimalUint) + if err := _Test.contract.UnpackLog(event, "log_named_decimal_uint", 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 +} + +// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_Test *TestFilterer) ParseLogNamedDecimalUint(log types.Log) (*TestLogNamedDecimalUint, error) { + event := new(TestLogNamedDecimalUint) + if err := _Test.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the Test contract. +type TestLogNamedIntIterator struct { + Event *TestLogNamedInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedInt represents a LogNamedInt event raised by the Test contract. +type TestLogNamedInt struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_Test *TestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*TestLogNamedIntIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return &TestLogNamedIntIterator{contract: _Test.contract, event: "log_named_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_Test *TestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *TestLogNamedInt) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedInt) + if err := _Test.contract.UnpackLog(event, "log_named_int", 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 +} + +// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_Test *TestFilterer) ParseLogNamedInt(log types.Log) (*TestLogNamedInt, error) { + event := new(TestLogNamedInt) + if err := _Test.contract.UnpackLog(event, "log_named_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the Test contract. +type TestLogNamedStringIterator struct { + Event *TestLogNamedString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedString represents a LogNamedString event raised by the Test contract. +type TestLogNamedString struct { + Key string + Val string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_Test *TestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*TestLogNamedStringIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return &TestLogNamedStringIterator{contract: _Test.contract, event: "log_named_string", logs: logs, sub: sub}, nil +} + +// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_Test *TestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *TestLogNamedString) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedString) + if err := _Test.contract.UnpackLog(event, "log_named_string", 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 +} + +// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_Test *TestFilterer) ParseLogNamedString(log types.Log) (*TestLogNamedString, error) { + event := new(TestLogNamedString) + if err := _Test.contract.UnpackLog(event, "log_named_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the Test contract. +type TestLogNamedUintIterator struct { + Event *TestLogNamedUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogNamedUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogNamedUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogNamedUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogNamedUint represents a LogNamedUint event raised by the Test contract. +type TestLogNamedUint struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_Test *TestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*TestLogNamedUintIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return &TestLogNamedUintIterator{contract: _Test.contract, event: "log_named_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_Test *TestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *TestLogNamedUint) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogNamedUint) + if err := _Test.contract.UnpackLog(event, "log_named_uint", 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 +} + +// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_Test *TestFilterer) ParseLogNamedUint(log types.Log) (*TestLogNamedUint, error) { + event := new(TestLogNamedUint) + if err := _Test.contract.UnpackLog(event, "log_named_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the Test contract. +type TestLogStringIterator struct { + Event *TestLogString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogString represents a LogString event raised by the Test contract. +type TestLogString struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_Test *TestFilterer) FilterLogString(opts *bind.FilterOpts) (*TestLogStringIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_string") + if err != nil { + return nil, err + } + return &TestLogStringIterator{contract: _Test.contract, event: "log_string", logs: logs, sub: sub}, nil +} + +// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_Test *TestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *TestLogString) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogString) + if err := _Test.contract.UnpackLog(event, "log_string", 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 +} + +// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_Test *TestFilterer) ParseLogString(log types.Log) (*TestLogString, error) { + event := new(TestLogString) + if err := _Test.contract.UnpackLog(event, "log_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the Test contract. +type TestLogUintIterator struct { + Event *TestLogUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogUint represents a LogUint event raised by the Test contract. +type TestLogUint struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_Test *TestFilterer) FilterLogUint(opts *bind.FilterOpts) (*TestLogUintIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return &TestLogUintIterator{contract: _Test.contract, event: "log_uint", logs: logs, sub: sub}, nil +} + +// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_Test *TestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *TestLogUint) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogUint) + if err := _Test.contract.UnpackLog(event, "log_uint", 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 +} + +// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_Test *TestFilterer) ParseLogUint(log types.Log) (*TestLogUint, error) { + event := new(TestLogUint) + if err := _Test.contract.UnpackLog(event, "log_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// TestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the Test contract. +type TestLogsIterator struct { + Event *TestLogs // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TestLogsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TestLogsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TestLogsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TestLogs represents a Logs event raised by the Test contract. +type TestLogs struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_Test *TestFilterer) FilterLogs(opts *bind.FilterOpts) (*TestLogsIterator, error) { + + logs, sub, err := _Test.contract.FilterLogs(opts, "logs") + if err != nil { + return nil, err + } + return &TestLogsIterator{contract: _Test.contract, event: "logs", logs: logs, sub: sub}, nil +} + +// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_Test *TestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *TestLogs) (event.Subscription, error) { + + logs, sub, err := _Test.contract.WatchLogs(opts, "logs") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TestLogs) + if err := _Test.contract.UnpackLog(event, "logs", 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 +} + +// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_Test *TestFilterer) ParseLogs(log types.Log) (*TestLogs, error) { + event := new(TestLogs) + if err := _Test.contract.UnpackLog(event, "logs", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/forge-std/vm.sol/vm.go b/pkg/forge-std/vm.sol/vm.go new file mode 100644 index 00000000..69a67d0c --- /dev/null +++ b/pkg/forge-std/vm.sol/vm.go @@ -0,0 +1,10783 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package vm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// VmSafeAccountAccess is an auto generated low-level Go binding around an user-defined struct. +type VmSafeAccountAccess struct { + ChainInfo VmSafeChainInfo + Kind uint8 + Account common.Address + Accessor common.Address + Initialized bool + OldBalance *big.Int + NewBalance *big.Int + DeployedCode []byte + Value *big.Int + Data []byte + Reverted bool + StorageAccesses []VmSafeStorageAccess + Depth uint64 +} + +// VmSafeChainInfo is an auto generated low-level Go binding around an user-defined struct. +type VmSafeChainInfo struct { + ForkId *big.Int + ChainId *big.Int +} + +// VmSafeDirEntry is an auto generated low-level Go binding around an user-defined struct. +type VmSafeDirEntry struct { + ErrorMessage string + Path string + Depth uint64 + IsDir bool + IsSymlink bool +} + +// VmSafeEthGetLogs is an auto generated low-level Go binding around an user-defined struct. +type VmSafeEthGetLogs struct { + Emitter common.Address + Topics [][32]byte + Data []byte + BlockHash [32]byte + BlockNumber uint64 + TransactionHash [32]byte + TransactionIndex uint64 + LogIndex *big.Int + Removed bool +} + +// VmSafeFfiResult is an auto generated low-level Go binding around an user-defined struct. +type VmSafeFfiResult struct { + ExitCode int32 + Stdout []byte + Stderr []byte +} + +// VmSafeFsMetadata is an auto generated low-level Go binding around an user-defined struct. +type VmSafeFsMetadata struct { + IsDir bool + IsSymlink bool + Length *big.Int + ReadOnly bool + Modified *big.Int + Accessed *big.Int + Created *big.Int +} + +// VmSafeGas is an auto generated low-level Go binding around an user-defined struct. +type VmSafeGas struct { + GasLimit uint64 + GasTotalUsed uint64 + GasMemoryUsed uint64 + GasRefunded int64 + GasRemaining uint64 +} + +// VmSafeLog is an auto generated low-level Go binding around an user-defined struct. +type VmSafeLog struct { + Topics [][32]byte + Data []byte + Emitter common.Address +} + +// VmSafeRpc is an auto generated low-level Go binding around an user-defined struct. +type VmSafeRpc struct { + Key string + Url string +} + +// VmSafeStorageAccess is an auto generated low-level Go binding around an user-defined struct. +type VmSafeStorageAccess struct { + Account common.Address + Slot [32]byte + IsWrite bool + PreviousValue [32]byte + NewValue [32]byte + Reverted bool +} + +// VmSafeWallet is an auto generated low-level Go binding around an user-defined struct. +type VmSafeWallet struct { + Addr common.Address + PublicKeyX *big.Int + PublicKeyY *big.Int + PrivateKey *big.Int +} + +// VmMetaData contains all meta data concerning the Vm contract. +var VmMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"accesses\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"readSlots\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"writeSlots\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"activeFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"allowCheatcodes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assume\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBlobBaseFee\",\"type\":\"uint256\"}],\"name\":\"blobBaseFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"hashes\",\"type\":\"bytes32[]\"}],\"name\":\"blobhashes\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newChainId\",\"type\":\"uint256\"}],\"name\":\"chainId\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"clearMockedCalls\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"closeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newCoinbase\",\"type\":\"address\"}],\"name\":\"coinbase\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"computeCreateAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"copyFile\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"copied\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"createDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"createFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"urlOrAlias\",\"type\":\"string\"}],\"name\":\"createSelectFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"}],\"name\":\"deal\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"deleteSnapshot\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deleteSnapshots\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newDifficulty\",\"type\":\"uint256\"}],\"name\":\"difficulty\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"pathToStateJson\",\"type\":\"string\"}],\"name\":\"dumpState\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"ensNamehash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"defaultValue\",\"type\":\"bytes32[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"defaultValue\",\"type\":\"int256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"defaultValue\",\"type\":\"bool\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"defaultValue\",\"type\":\"address\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"defaultValue\",\"type\":\"uint256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"defaultValue\",\"type\":\"bytes[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"defaultValue\",\"type\":\"uint256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"defaultValue\",\"type\":\"string[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"defaultValue\",\"type\":\"bytes\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"defaultValue\",\"type\":\"bytes32\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"defaultValue\",\"type\":\"int256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"defaultValue\",\"type\":\"address[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"defaultValue\",\"type\":\"string\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"defaultValue\",\"type\":\"bool[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"newRuntimeBytecode\",\"type\":\"bytes\"}],\"name\":\"etch\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fromBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBlock\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"}],\"name\":\"eth_getLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"transactionHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"transactionIndex\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"logIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"removed\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.EthGetLogs[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"exists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"gas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"minGas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"expectCallMinGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"uint64\",\"name\":\"minGas\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"count\",\"type\":\"uint64\"}],\"name\":\"expectCallMinGas\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"checkTopic1\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic2\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkTopic3\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"checkData\",\"type\":\"bool\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"name\":\"expectEmit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"revertData\",\"type\":\"bytes4\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"expectRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"min\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"max\",\"type\":\"uint64\"}],\"name\":\"expectSafeMemory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"min\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"max\",\"type\":\"uint64\"}],\"name\":\"expectSafeMemoryCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newBasefee\",\"type\":\"uint256\"}],\"name\":\"fee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"ffi\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"result\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"fsMetadata\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"readOnly\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"modified\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"accessed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"created\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.FsMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blobBaseFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobhashes\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"hashes\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"height\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"creationBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getDeployedCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"runtimeBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getLabel\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"currentLabel\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"elementSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingKeyAndParentOf\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"found\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parent\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingLength\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"getMappingSlotAt\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRecordedLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.Log[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"indexOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumVmSafe.ForgeContext\",\"name\":\"context\",\"type\":\"uint8\"}],\"name\":\"isContext\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isDir\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isFile\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isPersistent\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"persistent\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsJson\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsToml\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"newLabel\",\"type\":\"string\"}],\"name\":\"label\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastCallGas\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasTotalUsed\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasMemoryUsed\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"gasRefunded\",\"type\":\"int64\"},{\"internalType\":\"uint64\",\"name\":\"gasRemaining\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.Gas\",\"name\":\"gas\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"load\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"pathToAllocsJson\",\"type\":\"string\"}],\"name\":\"loadAllocs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account1\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account0\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account1\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account2\",\"type\":\"address\"}],\"name\":\"makePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"mockCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"msgValue\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"callee\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"mockCallRevert\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"parsedValue\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"parsedValue\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"parsedValue\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"parsedValue\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"parsedValue\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"parsedValue\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"}],\"name\":\"prank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"newPrevrandao\",\"type\":\"bytes32\"}],\"name\":\"prevrandao\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newPrevrandao\",\"type\":\"uint256\"}],\"name\":\"prevrandao\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"projectRoot\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"prompt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecret\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecretUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"readCallers\",\"outputs\":[{\"internalType\":\"enumVmSafe.CallerMode\",\"name\":\"callerMode\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"followLinks\",\"type\":\"bool\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFile\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFileBinary\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readLine\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"line\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"linkPath\",\"type\":\"string\"}],\"name\":\"readLink\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"targetPath\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"record\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"recordLogs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"rememberKey\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"removeDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"removeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"replace\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"resetNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertTo\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"name\":\"revertToAndDelete\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"}],\"name\":\"revokePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokePersistent\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newHeight\",\"type\":\"uint256\"}],\"name\":\"roll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"blockNumber\",\"type\":\"uint256\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"rollFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"rpcAlias\",\"type\":\"string\"}],\"name\":\"rpcUrl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrlStructs\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"url\",\"type\":\"string\"}],\"internalType\":\"structVmSafe.Rpc[]\",\"name\":\"urls\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrls\",\"outputs\":[{\"internalType\":\"string[2][]\",\"name\":\"urls\",\"type\":\"string[2][]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"}],\"name\":\"selectFork\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"values\",\"type\":\"address[]\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"values\",\"type\":\"bytes[]\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"values\",\"type\":\"bytes32[]\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"values\",\"type\":\"int256[]\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"values\",\"type\":\"string[]\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUintToHex\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setEnv\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newNonce\",\"type\":\"uint64\"}],\"name\":\"setNonce\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newNonce\",\"type\":\"uint64\"}],\"name\":\"setNonceUnsafe\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signP256\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"skipTest\",\"type\":\"bool\"}],\"name\":\"skip\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"sleep\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"snapshot\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"snapshotId\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delimiter\",\"type\":\"string\"}],\"name\":\"split\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"outputs\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"msgSender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"txOrigin\",\"type\":\"address\"}],\"name\":\"startPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startStateDiffRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnStateDiff\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.ChainInfo\",\"name\":\"chainInfo\",\"type\":\"tuple\"},{\"internalType\":\"enumVmSafe.AccountAccessKind\",\"name\":\"kind\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"accessor\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"oldBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"isWrite\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"previousValue\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newValue\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.StorageAccess[]\",\"name\":\"storageAccesses\",\"type\":\"tuple[]\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.AccountAccess[]\",\"name\":\"accountAccesses\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopExpectSafeMemory\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopPrank\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"store\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toLowercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toUppercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"transact\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"txHash\",\"type\":\"bytes32\"}],\"name\":\"transact\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"trim\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"tryFfi\",\"outputs\":[{\"components\":[{\"internalType\":\"int32\",\"name\":\"exitCode\",\"type\":\"int32\"},{\"internalType\":\"bytes\",\"name\":\"stdout\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"stderr\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.FfiResult\",\"name\":\"result\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newGasPrice\",\"type\":\"uint256\"}],\"name\":\"txGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unixTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"milliseconds\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newTimestamp\",\"type\":\"uint256\"}],\"name\":\"warp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"writeFileBinary\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeLine\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// VmABI is the input ABI used to generate the binding from. +// Deprecated: Use VmMetaData.ABI instead. +var VmABI = VmMetaData.ABI + +// Vm is an auto generated Go binding around an Ethereum contract. +type Vm struct { + VmCaller // Read-only binding to the contract + VmTransactor // Write-only binding to the contract + VmFilterer // Log filterer for contract events +} + +// VmCaller is an auto generated read-only Go binding around an Ethereum contract. +type VmCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmTransactor is an auto generated write-only Go binding around an Ethereum contract. +type VmTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type VmFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type VmSession struct { + Contract *Vm // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// VmCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type VmCallerSession struct { + Contract *VmCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// VmTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type VmTransactorSession struct { + Contract *VmTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// VmRaw is an auto generated low-level Go binding around an Ethereum contract. +type VmRaw struct { + Contract *Vm // Generic contract binding to access the raw methods on +} + +// VmCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type VmCallerRaw struct { + Contract *VmCaller // Generic read-only contract binding to access the raw methods on +} + +// VmTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type VmTransactorRaw struct { + Contract *VmTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewVm creates a new instance of Vm, bound to a specific deployed contract. +func NewVm(address common.Address, backend bind.ContractBackend) (*Vm, error) { + contract, err := bindVm(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Vm{VmCaller: VmCaller{contract: contract}, VmTransactor: VmTransactor{contract: contract}, VmFilterer: VmFilterer{contract: contract}}, nil +} + +// NewVmCaller creates a new read-only instance of Vm, bound to a specific deployed contract. +func NewVmCaller(address common.Address, caller bind.ContractCaller) (*VmCaller, error) { + contract, err := bindVm(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &VmCaller{contract: contract}, nil +} + +// NewVmTransactor creates a new write-only instance of Vm, bound to a specific deployed contract. +func NewVmTransactor(address common.Address, transactor bind.ContractTransactor) (*VmTransactor, error) { + contract, err := bindVm(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &VmTransactor{contract: contract}, nil +} + +// NewVmFilterer creates a new log filterer instance of Vm, bound to a specific deployed contract. +func NewVmFilterer(address common.Address, filterer bind.ContractFilterer) (*VmFilterer, error) { + contract, err := bindVm(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &VmFilterer{contract: contract}, nil +} + +// bindVm binds a generic wrapper to an already deployed contract. +func bindVm(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := VmMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Vm *VmRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Vm.Contract.VmCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Vm *VmRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.Contract.VmTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Vm *VmRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Vm.Contract.VmTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Vm *VmCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Vm.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Vm *VmTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Vm *VmTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Vm.Contract.contract.Transact(opts, method, params...) +} + +// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22. +// +// Solidity: function activeFork() view returns(uint256 forkId) +func (_Vm *VmCaller) ActiveFork(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "activeFork") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22. +// +// Solidity: function activeFork() view returns(uint256 forkId) +func (_Vm *VmSession) ActiveFork() (*big.Int, error) { + return _Vm.Contract.ActiveFork(&_Vm.CallOpts) +} + +// ActiveFork is a free data retrieval call binding the contract method 0x2f103f22. +// +// Solidity: function activeFork() view returns(uint256 forkId) +func (_Vm *VmCallerSession) ActiveFork() (*big.Int, error) { + return _Vm.Contract.ActiveFork(&_Vm.CallOpts) +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_Vm *VmCaller) Addr(opts *bind.CallOpts, privateKey *big.Int) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "addr", privateKey) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_Vm *VmSession) Addr(privateKey *big.Int) (common.Address, error) { + return _Vm.Contract.Addr(&_Vm.CallOpts, privateKey) +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_Vm *VmCallerSession) Addr(privateKey *big.Int) (common.Address, error) { + return _Vm.Contract.Addr(&_Vm.CallOpts, privateKey) +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbs(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs", left, right, maxDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_Vm *VmSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqAbs(&_Vm.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqAbs(&_Vm.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbs0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs0", left, right, maxDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_Vm *VmSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqAbs0(&_Vm.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqAbs0(&_Vm.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbs1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs1", left, right, maxDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbs1(&_Vm.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbs1(&_Vm.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbs2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbs2", left, right, maxDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbs2(&_Vm.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbs2(&_Vm.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbsDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal", left, right, maxDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqAbsDecimal(&_Vm.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqAbsDecimal(&_Vm.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbsDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal0", left, right, maxDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqAbsDecimal0(&_Vm.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqAbsDecimal0(&_Vm.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbsDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal1", left, right, maxDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbsDecimal1(&_Vm.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbsDecimal1(&_Vm.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqAbsDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqAbsDecimal2", left, right, maxDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbsDecimal2(&_Vm.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqAbsDecimal2(&_Vm.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqRel(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRel", left, right, maxPercentDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRel(&_Vm.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRel(&_Vm.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmCaller) AssertApproxEqRel0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRel0", left, right, maxPercentDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqRel0(&_Vm.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqRel0(&_Vm.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqRel1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRel1", left, right, maxPercentDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRel1(&_Vm.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRel1(&_Vm.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmCaller) AssertApproxEqRel2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRel2", left, right, maxPercentDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqRel2(&_Vm.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _Vm.Contract.AssertApproxEqRel2(&_Vm.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertApproxEqRelDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal", left, right, maxPercentDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqRelDecimal(&_Vm.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqRelDecimal(&_Vm.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqRelDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal0", left, right, maxPercentDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRelDecimal0(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRelDecimal0(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertApproxEqRelDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal1", left, right, maxPercentDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqRelDecimal1(&_Vm.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertApproxEqRelDecimal1(&_Vm.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertApproxEqRelDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertApproxEqRelDecimal2", left, right, maxPercentDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRelDecimal2(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertApproxEqRelDecimal2(&_Vm.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmCaller) AssertEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmSession) AssertEq(left [][32]byte, right [][32]byte) error { + return _Vm.Contract.AssertEq(&_Vm.CallOpts, left, right) +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq(left [][32]byte, right [][32]byte) error { + return _Vm.Contract.AssertEq(&_Vm.CallOpts, left, right) +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertEq0(&_Vm.CallOpts, left, right, error) +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertEq0(&_Vm.CallOpts, left, right, error) +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_Vm *VmCaller) AssertEq1(opts *bind.CallOpts, left common.Address, right common.Address, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_Vm *VmSession) AssertEq1(left common.Address, right common.Address, error string) error { + return _Vm.Contract.AssertEq1(&_Vm.CallOpts, left, right, error) +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq1(left common.Address, right common.Address, error string) error { + return _Vm.Contract.AssertEq1(&_Vm.CallOpts, left, right, error) +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertEq10(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq10", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertEq10(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertEq10(&_Vm.CallOpts, left, right, error) +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq10(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertEq10(&_Vm.CallOpts, left, right, error) +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmCaller) AssertEq11(opts *bind.CallOpts, left [32]byte, right [32]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq11", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmSession) AssertEq11(left [32]byte, right [32]byte) error { + return _Vm.Contract.AssertEq11(&_Vm.CallOpts, left, right) +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmCallerSession) AssertEq11(left [32]byte, right [32]byte) error { + return _Vm.Contract.AssertEq11(&_Vm.CallOpts, left, right) +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertEq12(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq12", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertEq12(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertEq12(&_Vm.CallOpts, left, right, error) +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq12(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertEq12(&_Vm.CallOpts, left, right, error) +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmCaller) AssertEq13(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq13", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmSession) AssertEq13(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertEq13(&_Vm.CallOpts, left, right) +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq13(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertEq13(&_Vm.CallOpts, left, right) +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_Vm *VmCaller) AssertEq14(opts *bind.CallOpts, left []byte, right []byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq14", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_Vm *VmSession) AssertEq14(left []byte, right []byte) error { + return _Vm.Contract.AssertEq14(&_Vm.CallOpts, left, right) +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_Vm *VmCallerSession) AssertEq14(left []byte, right []byte) error { + return _Vm.Contract.AssertEq14(&_Vm.CallOpts, left, right) +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertEq15(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq15", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertEq15(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertEq15(&_Vm.CallOpts, left, right) +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertEq15(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertEq15(&_Vm.CallOpts, left, right) +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmCaller) AssertEq16(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq16", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmSession) AssertEq16(left [32]byte, right [32]byte, error string) error { + return _Vm.Contract.AssertEq16(&_Vm.CallOpts, left, right, error) +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq16(left [32]byte, right [32]byte, error string) error { + return _Vm.Contract.AssertEq16(&_Vm.CallOpts, left, right, error) +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_Vm *VmCaller) AssertEq17(opts *bind.CallOpts, left []string, right []string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq17", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_Vm *VmSession) AssertEq17(left []string, right []string) error { + return _Vm.Contract.AssertEq17(&_Vm.CallOpts, left, right) +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq17(left []string, right []string) error { + return _Vm.Contract.AssertEq17(&_Vm.CallOpts, left, right) +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq18(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq18", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error { + return _Vm.Contract.AssertEq18(&_Vm.CallOpts, left, right, error) +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error { + return _Vm.Contract.AssertEq18(&_Vm.CallOpts, left, right, error) +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmCaller) AssertEq19(opts *bind.CallOpts, left []byte, right []byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq19", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmSession) AssertEq19(left []byte, right []byte, error string) error { + return _Vm.Contract.AssertEq19(&_Vm.CallOpts, left, right, error) +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq19(left []byte, right []byte, error string) error { + return _Vm.Contract.AssertEq19(&_Vm.CallOpts, left, right, error) +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_Vm *VmCaller) AssertEq2(opts *bind.CallOpts, left string, right string, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_Vm *VmSession) AssertEq2(left string, right string, error string) error { + return _Vm.Contract.AssertEq2(&_Vm.CallOpts, left, right, error) +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq2(left string, right string, error string) error { + return _Vm.Contract.AssertEq2(&_Vm.CallOpts, left, right, error) +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq20(opts *bind.CallOpts, left []bool, right []bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq20", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq20(left []bool, right []bool, error string) error { + return _Vm.Contract.AssertEq20(&_Vm.CallOpts, left, right, error) +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq20(left []bool, right []bool, error string) error { + return _Vm.Contract.AssertEq20(&_Vm.CallOpts, left, right, error) +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmCaller) AssertEq21(opts *bind.CallOpts, left [][]byte, right [][]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq21", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmSession) AssertEq21(left [][]byte, right [][]byte) error { + return _Vm.Contract.AssertEq21(&_Vm.CallOpts, left, right) +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq21(left [][]byte, right [][]byte) error { + return _Vm.Contract.AssertEq21(&_Vm.CallOpts, left, right) +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq22(opts *bind.CallOpts, left []string, right []string, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq22", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq22(left []string, right []string, error string) error { + return _Vm.Contract.AssertEq22(&_Vm.CallOpts, left, right, error) +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq22(left []string, right []string, error string) error { + return _Vm.Contract.AssertEq22(&_Vm.CallOpts, left, right, error) +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_Vm *VmCaller) AssertEq23(opts *bind.CallOpts, left string, right string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq23", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_Vm *VmSession) AssertEq23(left string, right string) error { + return _Vm.Contract.AssertEq23(&_Vm.CallOpts, left, right) +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_Vm *VmCallerSession) AssertEq23(left string, right string) error { + return _Vm.Contract.AssertEq23(&_Vm.CallOpts, left, right) +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq24(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq24", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq24(left [][]byte, right [][]byte, error string) error { + return _Vm.Contract.AssertEq24(&_Vm.CallOpts, left, right, error) +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq24(left [][]byte, right [][]byte, error string) error { + return _Vm.Contract.AssertEq24(&_Vm.CallOpts, left, right, error) +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_Vm *VmCaller) AssertEq25(opts *bind.CallOpts, left bool, right bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq25", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_Vm *VmSession) AssertEq25(left bool, right bool) error { + return _Vm.Contract.AssertEq25(&_Vm.CallOpts, left, right) +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_Vm *VmCallerSession) AssertEq25(left bool, right bool) error { + return _Vm.Contract.AssertEq25(&_Vm.CallOpts, left, right) +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq26", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertEq26(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertEq26(&_Vm.CallOpts, left, right) +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertEq26(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertEq26(&_Vm.CallOpts, left, right) +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_Vm *VmCaller) AssertEq3(opts *bind.CallOpts, left []common.Address, right []common.Address) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq3", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_Vm *VmSession) AssertEq3(left []common.Address, right []common.Address) error { + return _Vm.Contract.AssertEq3(&_Vm.CallOpts, left, right) +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq3(left []common.Address, right []common.Address) error { + return _Vm.Contract.AssertEq3(&_Vm.CallOpts, left, right) +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq4(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq4", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq4(left []common.Address, right []common.Address, error string) error { + return _Vm.Contract.AssertEq4(&_Vm.CallOpts, left, right, error) +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq4(left []common.Address, right []common.Address, error string) error { + return _Vm.Contract.AssertEq4(&_Vm.CallOpts, left, right, error) +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_Vm *VmCaller) AssertEq5(opts *bind.CallOpts, left bool, right bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq5", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_Vm *VmSession) AssertEq5(left bool, right bool, error string) error { + return _Vm.Contract.AssertEq5(&_Vm.CallOpts, left, right, error) +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq5(left bool, right bool, error string) error { + return _Vm.Contract.AssertEq5(&_Vm.CallOpts, left, right, error) +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_Vm *VmCaller) AssertEq6(opts *bind.CallOpts, left common.Address, right common.Address) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq6", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_Vm *VmSession) AssertEq6(left common.Address, right common.Address) error { + return _Vm.Contract.AssertEq6(&_Vm.CallOpts, left, right) +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_Vm *VmCallerSession) AssertEq6(left common.Address, right common.Address) error { + return _Vm.Contract.AssertEq6(&_Vm.CallOpts, left, right) +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmCaller) AssertEq7(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq7", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertEq7(&_Vm.CallOpts, left, right, error) +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertEq7(&_Vm.CallOpts, left, right, error) +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmCaller) AssertEq8(opts *bind.CallOpts, left []bool, right []bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq8", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmSession) AssertEq8(left []bool, right []bool) error { + return _Vm.Contract.AssertEq8(&_Vm.CallOpts, left, right) +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq8(left []bool, right []bool) error { + return _Vm.Contract.AssertEq8(&_Vm.CallOpts, left, right) +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmCaller) AssertEq9(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEq9", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmSession) AssertEq9(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertEq9(&_Vm.CallOpts, left, right) +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmCallerSession) AssertEq9(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertEq9(&_Vm.CallOpts, left, right) +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEqDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertEqDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertEqDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEqDecimal0", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertEqDecimal0(&_Vm.CallOpts, left, right, decimals) +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertEqDecimal0(&_Vm.CallOpts, left, right, decimals) +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEqDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertEqDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertEqDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertEqDecimal2", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertEqDecimal2(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertEqDecimal2(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_Vm *VmCaller) AssertFalse(opts *bind.CallOpts, condition bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertFalse", condition, error) + + if err != nil { + return err + } + + return err + +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_Vm *VmSession) AssertFalse(condition bool, error string) error { + return _Vm.Contract.AssertFalse(&_Vm.CallOpts, condition, error) +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_Vm *VmCallerSession) AssertFalse(condition bool, error string) error { + return _Vm.Contract.AssertFalse(&_Vm.CallOpts, condition, error) +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_Vm *VmCaller) AssertFalse0(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertFalse0", condition) + + if err != nil { + return err + } + + return err + +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_Vm *VmSession) AssertFalse0(condition bool) error { + return _Vm.Contract.AssertFalse0(&_Vm.CallOpts, condition) +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_Vm *VmCallerSession) AssertFalse0(condition bool) error { + return _Vm.Contract.AssertFalse0(&_Vm.CallOpts, condition) +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertGe(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGe", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertGe(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGe(&_Vm.CallOpts, left, right) +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertGe(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGe(&_Vm.CallOpts, left, right) +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertGe0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGe0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertGe0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGe0(&_Vm.CallOpts, left, right, error) +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertGe0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGe0(&_Vm.CallOpts, left, right, error) +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertGe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGe1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertGe1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGe1(&_Vm.CallOpts, left, right) +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertGe1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGe1(&_Vm.CallOpts, left, right) +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertGe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGe2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertGe2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGe2(&_Vm.CallOpts, left, right, error) +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertGe2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGe2(&_Vm.CallOpts, left, right, error) +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertGeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGeDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGeDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGeDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertGeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGeDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGeDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGeDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertGeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGeDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGeDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGeDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertGeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGeDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGeDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGeDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertGt(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGt", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertGt(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGt(&_Vm.CallOpts, left, right) +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertGt(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGt(&_Vm.CallOpts, left, right) +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertGt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGt0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertGt0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGt0(&_Vm.CallOpts, left, right, error) +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertGt0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGt0(&_Vm.CallOpts, left, right, error) +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertGt1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGt1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertGt1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGt1(&_Vm.CallOpts, left, right) +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertGt1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertGt1(&_Vm.CallOpts, left, right) +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertGt2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGt2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertGt2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGt2(&_Vm.CallOpts, left, right, error) +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertGt2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertGt2(&_Vm.CallOpts, left, right, error) +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertGtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGtDecimal", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGtDecimal(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGtDecimal(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertGtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGtDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGtDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertGtDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertGtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGtDecimal1", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGtDecimal1(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGtDecimal1(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertGtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertGtDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGtDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertGtDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertLe(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLe", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertLe(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLe(&_Vm.CallOpts, left, right, error) +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertLe(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLe(&_Vm.CallOpts, left, right, error) +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertLe0(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLe0", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertLe0(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLe0(&_Vm.CallOpts, left, right) +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertLe0(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLe0(&_Vm.CallOpts, left, right) +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertLe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLe1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertLe1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLe1(&_Vm.CallOpts, left, right) +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertLe1(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLe1(&_Vm.CallOpts, left, right) +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertLe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLe2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertLe2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLe2(&_Vm.CallOpts, left, right, error) +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertLe2(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLe2(&_Vm.CallOpts, left, right, error) +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertLeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLeDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLeDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLeDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertLeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLeDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLeDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLeDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertLeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLeDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLeDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLeDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertLeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLeDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLeDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLeDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertLt(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLt", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertLt(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLt(&_Vm.CallOpts, left, right) +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertLt(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLt(&_Vm.CallOpts, left, right) +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertLt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLt0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertLt0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLt0(&_Vm.CallOpts, left, right, error) +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertLt0(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLt0(&_Vm.CallOpts, left, right, error) +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertLt1(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLt1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertLt1(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLt1(&_Vm.CallOpts, left, right, error) +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertLt1(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertLt1(&_Vm.CallOpts, left, right, error) +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertLt2(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLt2", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertLt2(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLt2(&_Vm.CallOpts, left, right) +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertLt2(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertLt2(&_Vm.CallOpts, left, right) +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertLtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLtDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLtDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLtDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertLtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLtDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLtDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLtDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertLtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLtDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLtDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertLtDecimal1(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertLtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertLtDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLtDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertLtDecimal2(&_Vm.CallOpts, left, right, decimals) +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmSession) AssertNotEq(left [][32]byte, right [][32]byte) error { + return _Vm.Contract.AssertNotEq(&_Vm.CallOpts, left, right) +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq(left [][32]byte, right [][32]byte) error { + return _Vm.Contract.AssertNotEq(&_Vm.CallOpts, left, right) +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq0", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmSession) AssertNotEq0(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertNotEq0(&_Vm.CallOpts, left, right) +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq0(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertNotEq0(&_Vm.CallOpts, left, right) +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq1(opts *bind.CallOpts, left bool, right bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq1(left bool, right bool, error string) error { + return _Vm.Contract.AssertNotEq1(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq1(left bool, right bool, error string) error { + return _Vm.Contract.AssertNotEq1(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_Vm *VmCaller) AssertNotEq10(opts *bind.CallOpts, left string, right string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq10", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_Vm *VmSession) AssertNotEq10(left string, right string) error { + return _Vm.Contract.AssertNotEq10(&_Vm.CallOpts, left, right) +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq10(left string, right string) error { + return _Vm.Contract.AssertNotEq10(&_Vm.CallOpts, left, right) +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq11(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq11", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error { + return _Vm.Contract.AssertNotEq11(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error { + return _Vm.Contract.AssertNotEq11(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq12(opts *bind.CallOpts, left string, right string, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq12", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq12(left string, right string, error string) error { + return _Vm.Contract.AssertNotEq12(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq12(left string, right string, error string) error { + return _Vm.Contract.AssertNotEq12(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq13(opts *bind.CallOpts, left common.Address, right common.Address, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq13", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq13(left common.Address, right common.Address, error string) error { + return _Vm.Contract.AssertNotEq13(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq13(left common.Address, right common.Address, error string) error { + return _Vm.Contract.AssertNotEq13(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmCaller) AssertNotEq14(opts *bind.CallOpts, left [32]byte, right [32]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq14", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmSession) AssertNotEq14(left [32]byte, right [32]byte) error { + return _Vm.Contract.AssertNotEq14(&_Vm.CallOpts, left, right) +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq14(left [32]byte, right [32]byte) error { + return _Vm.Contract.AssertNotEq14(&_Vm.CallOpts, left, right) +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq15(opts *bind.CallOpts, left []byte, right []byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq15", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq15(left []byte, right []byte, error string) error { + return _Vm.Contract.AssertNotEq15(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq15(left []byte, right []byte, error string) error { + return _Vm.Contract.AssertNotEq15(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq16(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq16", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertNotEq16(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertNotEq16(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq17(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq17", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertNotEq17(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertNotEq17(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_Vm *VmCaller) AssertNotEq18(opts *bind.CallOpts, left common.Address, right common.Address) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq18", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_Vm *VmSession) AssertNotEq18(left common.Address, right common.Address) error { + return _Vm.Contract.AssertNotEq18(&_Vm.CallOpts, left, right) +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq18(left common.Address, right common.Address) error { + return _Vm.Contract.AssertNotEq18(&_Vm.CallOpts, left, right) +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq19(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq19", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error { + return _Vm.Contract.AssertNotEq19(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error { + return _Vm.Contract.AssertNotEq19(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq2(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error { + return _Vm.Contract.AssertNotEq2(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error { + return _Vm.Contract.AssertNotEq2(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq20(opts *bind.CallOpts, left []string, right []string, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq20", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq20(left []string, right []string, error string) error { + return _Vm.Contract.AssertNotEq20(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq20(left []string, right []string, error string) error { + return _Vm.Contract.AssertNotEq20(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmCaller) AssertNotEq21(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq21", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmSession) AssertNotEq21(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertNotEq21(&_Vm.CallOpts, left, right) +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq21(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertNotEq21(&_Vm.CallOpts, left, right) +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq22(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq22", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error { + return _Vm.Contract.AssertNotEq22(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error { + return _Vm.Contract.AssertNotEq22(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq23(opts *bind.CallOpts, left []string, right []string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq23", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_Vm *VmSession) AssertNotEq23(left []string, right []string) error { + return _Vm.Contract.AssertNotEq23(&_Vm.CallOpts, left, right) +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq23(left []string, right []string) error { + return _Vm.Contract.AssertNotEq23(&_Vm.CallOpts, left, right) +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq24(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq24", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertNotEq24(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error { + return _Vm.Contract.AssertNotEq24(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq25(opts *bind.CallOpts, left [][]byte, right [][]byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq25", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmSession) AssertNotEq25(left [][]byte, right [][]byte) error { + return _Vm.Contract.AssertNotEq25(&_Vm.CallOpts, left, right) +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq25(left [][]byte, right [][]byte) error { + return _Vm.Contract.AssertNotEq25(&_Vm.CallOpts, left, right) +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_Vm *VmCaller) AssertNotEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq26", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_Vm *VmSession) AssertNotEq26(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertNotEq26(&_Vm.CallOpts, left, right) +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq26(left *big.Int, right *big.Int) error { + return _Vm.Contract.AssertNotEq26(&_Vm.CallOpts, left, right) +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_Vm *VmCaller) AssertNotEq3(opts *bind.CallOpts, left bool, right bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq3", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_Vm *VmSession) AssertNotEq3(left bool, right bool) error { + return _Vm.Contract.AssertNotEq3(&_Vm.CallOpts, left, right) +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq3(left bool, right bool) error { + return _Vm.Contract.AssertNotEq3(&_Vm.CallOpts, left, right) +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq4(opts *bind.CallOpts, left []bool, right []bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq4", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmSession) AssertNotEq4(left []bool, right []bool) error { + return _Vm.Contract.AssertNotEq4(&_Vm.CallOpts, left, right) +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq4(left []bool, right []bool) error { + return _Vm.Contract.AssertNotEq4(&_Vm.CallOpts, left, right) +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_Vm *VmCaller) AssertNotEq5(opts *bind.CallOpts, left []byte, right []byte) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq5", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_Vm *VmSession) AssertNotEq5(left []byte, right []byte) error { + return _Vm.Contract.AssertNotEq5(&_Vm.CallOpts, left, right) +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq5(left []byte, right []byte) error { + return _Vm.Contract.AssertNotEq5(&_Vm.CallOpts, left, right) +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq6(opts *bind.CallOpts, left []common.Address, right []common.Address) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq6", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_Vm *VmSession) AssertNotEq6(left []common.Address, right []common.Address) error { + return _Vm.Contract.AssertNotEq6(&_Vm.CallOpts, left, right) +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq6(left []common.Address, right []common.Address) error { + return _Vm.Contract.AssertNotEq6(&_Vm.CallOpts, left, right) +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq7(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq7", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertNotEq7(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error { + return _Vm.Contract.AssertNotEq7(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmCaller) AssertNotEq8(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq8", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmSession) AssertNotEq8(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertNotEq8(&_Vm.CallOpts, left, right) +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_Vm *VmCallerSession) AssertNotEq8(left []*big.Int, right []*big.Int) error { + return _Vm.Contract.AssertNotEq8(&_Vm.CallOpts, left, right) +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmCaller) AssertNotEq9(opts *bind.CallOpts, left []bool, right []bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEq9", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmSession) AssertNotEq9(left []bool, right []bool, error string) error { + return _Vm.Contract.AssertNotEq9(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEq9(left []bool, right []bool, error string) error { + return _Vm.Contract.AssertNotEq9(&_Vm.CallOpts, left, right, error) +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertNotEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertNotEqDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertNotEqDecimal(&_Vm.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertNotEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertNotEqDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertNotEqDecimal0(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCaller) AssertNotEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal1", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertNotEqDecimal1(&_Vm.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_Vm *VmCallerSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _Vm.Contract.AssertNotEqDecimal1(&_Vm.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCaller) AssertNotEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertNotEqDecimal2", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertNotEqDecimal2(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_Vm *VmCallerSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _Vm.Contract.AssertNotEqDecimal2(&_Vm.CallOpts, left, right, decimals, error) +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_Vm *VmCaller) AssertTrue(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertTrue", condition) + + if err != nil { + return err + } + + return err + +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_Vm *VmSession) AssertTrue(condition bool) error { + return _Vm.Contract.AssertTrue(&_Vm.CallOpts, condition) +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_Vm *VmCallerSession) AssertTrue(condition bool) error { + return _Vm.Contract.AssertTrue(&_Vm.CallOpts, condition) +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_Vm *VmCaller) AssertTrue0(opts *bind.CallOpts, condition bool, error string) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assertTrue0", condition, error) + + if err != nil { + return err + } + + return err + +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_Vm *VmSession) AssertTrue0(condition bool, error string) error { + return _Vm.Contract.AssertTrue0(&_Vm.CallOpts, condition, error) +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_Vm *VmCallerSession) AssertTrue0(condition bool, error string) error { + return _Vm.Contract.AssertTrue0(&_Vm.CallOpts, condition, error) +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_Vm *VmCaller) Assume(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "assume", condition) + + if err != nil { + return err + } + + return err + +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_Vm *VmSession) Assume(condition bool) error { + return _Vm.Contract.Assume(&_Vm.CallOpts, condition) +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_Vm *VmCallerSession) Assume(condition bool) error { + return _Vm.Contract.Assume(&_Vm.CallOpts, condition) +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_Vm *VmCaller) ComputeCreate2Address(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "computeCreate2Address", salt, initCodeHash) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_Vm *VmSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + return _Vm.Contract.ComputeCreate2Address(&_Vm.CallOpts, salt, initCodeHash) +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_Vm *VmCallerSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + return _Vm.Contract.ComputeCreate2Address(&_Vm.CallOpts, salt, initCodeHash) +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_Vm *VmCaller) ComputeCreate2Address0(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "computeCreate2Address0", salt, initCodeHash, deployer) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_Vm *VmSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + return _Vm.Contract.ComputeCreate2Address0(&_Vm.CallOpts, salt, initCodeHash, deployer) +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_Vm *VmCallerSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + return _Vm.Contract.ComputeCreate2Address0(&_Vm.CallOpts, salt, initCodeHash, deployer) +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_Vm *VmCaller) ComputeCreateAddress(opts *bind.CallOpts, deployer common.Address, nonce *big.Int) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "computeCreateAddress", deployer, nonce) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_Vm *VmSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) { + return _Vm.Contract.ComputeCreateAddress(&_Vm.CallOpts, deployer, nonce) +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_Vm *VmCallerSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) { + return _Vm.Contract.ComputeCreateAddress(&_Vm.CallOpts, deployer, nonce) +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmCaller) DeriveKey(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "deriveKey", mnemonic, derivationPath, index, language) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + return _Vm.Contract.DeriveKey(&_Vm.CallOpts, mnemonic, derivationPath, index, language) +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmCallerSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + return _Vm.Contract.DeriveKey(&_Vm.CallOpts, mnemonic, derivationPath, index, language) +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmCaller) DeriveKey0(opts *bind.CallOpts, mnemonic string, index uint32, language string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "deriveKey0", mnemonic, index, language) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) { + return _Vm.Contract.DeriveKey0(&_Vm.CallOpts, mnemonic, index, language) +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_Vm *VmCallerSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) { + return _Vm.Contract.DeriveKey0(&_Vm.CallOpts, mnemonic, index, language) +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmCaller) DeriveKey1(opts *bind.CallOpts, mnemonic string, index uint32) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "deriveKey1", mnemonic, index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) { + return _Vm.Contract.DeriveKey1(&_Vm.CallOpts, mnemonic, index) +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmCallerSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) { + return _Vm.Contract.DeriveKey1(&_Vm.CallOpts, mnemonic, index) +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmCaller) DeriveKey2(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "deriveKey2", mnemonic, derivationPath, index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + return _Vm.Contract.DeriveKey2(&_Vm.CallOpts, mnemonic, derivationPath, index) +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_Vm *VmCallerSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + return _Vm.Contract.DeriveKey2(&_Vm.CallOpts, mnemonic, derivationPath, index) +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_Vm *VmCaller) EnsNamehash(opts *bind.CallOpts, name string) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "ensNamehash", name) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_Vm *VmSession) EnsNamehash(name string) ([32]byte, error) { + return _Vm.Contract.EnsNamehash(&_Vm.CallOpts, name) +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_Vm *VmCallerSession) EnsNamehash(name string) ([32]byte, error) { + return _Vm.Contract.EnsNamehash(&_Vm.CallOpts, name) +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_Vm *VmCaller) EnvAddress(opts *bind.CallOpts, name string) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envAddress", name) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_Vm *VmSession) EnvAddress(name string) (common.Address, error) { + return _Vm.Contract.EnvAddress(&_Vm.CallOpts, name) +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_Vm *VmCallerSession) EnvAddress(name string) (common.Address, error) { + return _Vm.Contract.EnvAddress(&_Vm.CallOpts, name) +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_Vm *VmCaller) EnvAddress0(opts *bind.CallOpts, name string, delim string) ([]common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envAddress0", name, delim) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_Vm *VmSession) EnvAddress0(name string, delim string) ([]common.Address, error) { + return _Vm.Contract.EnvAddress0(&_Vm.CallOpts, name, delim) +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_Vm *VmCallerSession) EnvAddress0(name string, delim string) ([]common.Address, error) { + return _Vm.Contract.EnvAddress0(&_Vm.CallOpts, name, delim) +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_Vm *VmCaller) EnvBool(opts *bind.CallOpts, name string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBool", name) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_Vm *VmSession) EnvBool(name string) (bool, error) { + return _Vm.Contract.EnvBool(&_Vm.CallOpts, name) +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_Vm *VmCallerSession) EnvBool(name string) (bool, error) { + return _Vm.Contract.EnvBool(&_Vm.CallOpts, name) +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_Vm *VmCaller) EnvBool0(opts *bind.CallOpts, name string, delim string) ([]bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBool0", name, delim) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_Vm *VmSession) EnvBool0(name string, delim string) ([]bool, error) { + return _Vm.Contract.EnvBool0(&_Vm.CallOpts, name, delim) +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_Vm *VmCallerSession) EnvBool0(name string, delim string) ([]bool, error) { + return _Vm.Contract.EnvBool0(&_Vm.CallOpts, name, delim) +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_Vm *VmCaller) EnvBytes(opts *bind.CallOpts, name string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBytes", name) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_Vm *VmSession) EnvBytes(name string) ([]byte, error) { + return _Vm.Contract.EnvBytes(&_Vm.CallOpts, name) +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_Vm *VmCallerSession) EnvBytes(name string) ([]byte, error) { + return _Vm.Contract.EnvBytes(&_Vm.CallOpts, name) +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_Vm *VmCaller) EnvBytes0(opts *bind.CallOpts, name string, delim string) ([][]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBytes0", name, delim) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_Vm *VmSession) EnvBytes0(name string, delim string) ([][]byte, error) { + return _Vm.Contract.EnvBytes0(&_Vm.CallOpts, name, delim) +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_Vm *VmCallerSession) EnvBytes0(name string, delim string) ([][]byte, error) { + return _Vm.Contract.EnvBytes0(&_Vm.CallOpts, name, delim) +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_Vm *VmCaller) EnvBytes32(opts *bind.CallOpts, name string, delim string) ([][32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBytes32", name, delim) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_Vm *VmSession) EnvBytes32(name string, delim string) ([][32]byte, error) { + return _Vm.Contract.EnvBytes32(&_Vm.CallOpts, name, delim) +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_Vm *VmCallerSession) EnvBytes32(name string, delim string) ([][32]byte, error) { + return _Vm.Contract.EnvBytes32(&_Vm.CallOpts, name, delim) +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_Vm *VmCaller) EnvBytes320(opts *bind.CallOpts, name string) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envBytes320", name) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_Vm *VmSession) EnvBytes320(name string) ([32]byte, error) { + return _Vm.Contract.EnvBytes320(&_Vm.CallOpts, name) +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_Vm *VmCallerSession) EnvBytes320(name string) ([32]byte, error) { + return _Vm.Contract.EnvBytes320(&_Vm.CallOpts, name) +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_Vm *VmCaller) EnvExists(opts *bind.CallOpts, name string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envExists", name) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_Vm *VmSession) EnvExists(name string) (bool, error) { + return _Vm.Contract.EnvExists(&_Vm.CallOpts, name) +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_Vm *VmCallerSession) EnvExists(name string) (bool, error) { + return _Vm.Contract.EnvExists(&_Vm.CallOpts, name) +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_Vm *VmCaller) EnvInt(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envInt", name, delim) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_Vm *VmSession) EnvInt(name string, delim string) ([]*big.Int, error) { + return _Vm.Contract.EnvInt(&_Vm.CallOpts, name, delim) +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_Vm *VmCallerSession) EnvInt(name string, delim string) ([]*big.Int, error) { + return _Vm.Contract.EnvInt(&_Vm.CallOpts, name, delim) +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_Vm *VmCaller) EnvInt0(opts *bind.CallOpts, name string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envInt0", name) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_Vm *VmSession) EnvInt0(name string) (*big.Int, error) { + return _Vm.Contract.EnvInt0(&_Vm.CallOpts, name) +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_Vm *VmCallerSession) EnvInt0(name string) (*big.Int, error) { + return _Vm.Contract.EnvInt0(&_Vm.CallOpts, name) +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_Vm *VmCaller) EnvOr(opts *bind.CallOpts, name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr", name, delim, defaultValue) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_Vm *VmSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + return _Vm.Contract.EnvOr(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_Vm *VmCallerSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + return _Vm.Contract.EnvOr(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_Vm *VmCaller) EnvOr0(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr0", name, delim, defaultValue) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_Vm *VmSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _Vm.Contract.EnvOr0(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_Vm *VmCallerSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _Vm.Contract.EnvOr0(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_Vm *VmCaller) EnvOr1(opts *bind.CallOpts, name string, defaultValue bool) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr1", name, defaultValue) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_Vm *VmSession) EnvOr1(name string, defaultValue bool) (bool, error) { + return _Vm.Contract.EnvOr1(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_Vm *VmCallerSession) EnvOr1(name string, defaultValue bool) (bool, error) { + return _Vm.Contract.EnvOr1(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_Vm *VmCaller) EnvOr10(opts *bind.CallOpts, name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr10", name, delim, defaultValue) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_Vm *VmSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + return _Vm.Contract.EnvOr10(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_Vm *VmCallerSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + return _Vm.Contract.EnvOr10(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_Vm *VmCaller) EnvOr11(opts *bind.CallOpts, name string, defaultValue string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr11", name, defaultValue) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_Vm *VmSession) EnvOr11(name string, defaultValue string) (string, error) { + return _Vm.Contract.EnvOr11(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_Vm *VmCallerSession) EnvOr11(name string, defaultValue string) (string, error) { + return _Vm.Contract.EnvOr11(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_Vm *VmCaller) EnvOr12(opts *bind.CallOpts, name string, delim string, defaultValue []bool) ([]bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr12", name, delim, defaultValue) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_Vm *VmSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) { + return _Vm.Contract.EnvOr12(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_Vm *VmCallerSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) { + return _Vm.Contract.EnvOr12(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_Vm *VmCaller) EnvOr2(opts *bind.CallOpts, name string, defaultValue common.Address) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr2", name, defaultValue) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_Vm *VmSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) { + return _Vm.Contract.EnvOr2(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_Vm *VmCallerSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) { + return _Vm.Contract.EnvOr2(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_Vm *VmCaller) EnvOr3(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr3", name, defaultValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_Vm *VmSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) { + return _Vm.Contract.EnvOr3(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_Vm *VmCallerSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) { + return _Vm.Contract.EnvOr3(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_Vm *VmCaller) EnvOr4(opts *bind.CallOpts, name string, delim string, defaultValue [][]byte) ([][]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr4", name, delim, defaultValue) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_Vm *VmSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) { + return _Vm.Contract.EnvOr4(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_Vm *VmCallerSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) { + return _Vm.Contract.EnvOr4(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_Vm *VmCaller) EnvOr5(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr5", name, delim, defaultValue) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_Vm *VmSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _Vm.Contract.EnvOr5(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_Vm *VmCallerSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _Vm.Contract.EnvOr5(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_Vm *VmCaller) EnvOr6(opts *bind.CallOpts, name string, delim string, defaultValue []string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr6", name, delim, defaultValue) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_Vm *VmSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) { + return _Vm.Contract.EnvOr6(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_Vm *VmCallerSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) { + return _Vm.Contract.EnvOr6(&_Vm.CallOpts, name, delim, defaultValue) +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_Vm *VmCaller) EnvOr7(opts *bind.CallOpts, name string, defaultValue []byte) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr7", name, defaultValue) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_Vm *VmSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) { + return _Vm.Contract.EnvOr7(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_Vm *VmCallerSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) { + return _Vm.Contract.EnvOr7(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_Vm *VmCaller) EnvOr8(opts *bind.CallOpts, name string, defaultValue [32]byte) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr8", name, defaultValue) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_Vm *VmSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) { + return _Vm.Contract.EnvOr8(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_Vm *VmCallerSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) { + return _Vm.Contract.EnvOr8(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_Vm *VmCaller) EnvOr9(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envOr9", name, defaultValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_Vm *VmSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) { + return _Vm.Contract.EnvOr9(&_Vm.CallOpts, name, defaultValue) +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_Vm *VmCallerSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) { + return _Vm.Contract.EnvOr9(&_Vm.CallOpts, name, defaultValue) +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_Vm *VmCaller) EnvString(opts *bind.CallOpts, name string, delim string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envString", name, delim) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_Vm *VmSession) EnvString(name string, delim string) ([]string, error) { + return _Vm.Contract.EnvString(&_Vm.CallOpts, name, delim) +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_Vm *VmCallerSession) EnvString(name string, delim string) ([]string, error) { + return _Vm.Contract.EnvString(&_Vm.CallOpts, name, delim) +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_Vm *VmCaller) EnvString0(opts *bind.CallOpts, name string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envString0", name) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_Vm *VmSession) EnvString0(name string) (string, error) { + return _Vm.Contract.EnvString0(&_Vm.CallOpts, name) +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_Vm *VmCallerSession) EnvString0(name string) (string, error) { + return _Vm.Contract.EnvString0(&_Vm.CallOpts, name) +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_Vm *VmCaller) EnvUint(opts *bind.CallOpts, name string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envUint", name) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_Vm *VmSession) EnvUint(name string) (*big.Int, error) { + return _Vm.Contract.EnvUint(&_Vm.CallOpts, name) +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_Vm *VmCallerSession) EnvUint(name string) (*big.Int, error) { + return _Vm.Contract.EnvUint(&_Vm.CallOpts, name) +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_Vm *VmCaller) EnvUint0(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "envUint0", name, delim) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_Vm *VmSession) EnvUint0(name string, delim string) ([]*big.Int, error) { + return _Vm.Contract.EnvUint0(&_Vm.CallOpts, name, delim) +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_Vm *VmCallerSession) EnvUint0(name string, delim string) ([]*big.Int, error) { + return _Vm.Contract.EnvUint0(&_Vm.CallOpts, name, delim) +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_Vm *VmCaller) FsMetadata(opts *bind.CallOpts, path string) (VmSafeFsMetadata, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "fsMetadata", path) + + if err != nil { + return *new(VmSafeFsMetadata), err + } + + out0 := *abi.ConvertType(out[0], new(VmSafeFsMetadata)).(*VmSafeFsMetadata) + + return out0, err + +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_Vm *VmSession) FsMetadata(path string) (VmSafeFsMetadata, error) { + return _Vm.Contract.FsMetadata(&_Vm.CallOpts, path) +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_Vm *VmCallerSession) FsMetadata(path string) (VmSafeFsMetadata, error) { + return _Vm.Contract.FsMetadata(&_Vm.CallOpts, path) +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_Vm *VmCaller) GetBlobBaseFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getBlobBaseFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_Vm *VmSession) GetBlobBaseFee() (*big.Int, error) { + return _Vm.Contract.GetBlobBaseFee(&_Vm.CallOpts) +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_Vm *VmCallerSession) GetBlobBaseFee() (*big.Int, error) { + return _Vm.Contract.GetBlobBaseFee(&_Vm.CallOpts) +} + +// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b. +// +// Solidity: function getBlobhashes() view returns(bytes32[] hashes) +func (_Vm *VmCaller) GetBlobhashes(opts *bind.CallOpts) ([][32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getBlobhashes") + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b. +// +// Solidity: function getBlobhashes() view returns(bytes32[] hashes) +func (_Vm *VmSession) GetBlobhashes() ([][32]byte, error) { + return _Vm.Contract.GetBlobhashes(&_Vm.CallOpts) +} + +// GetBlobhashes is a free data retrieval call binding the contract method 0xf56ff18b. +// +// Solidity: function getBlobhashes() view returns(bytes32[] hashes) +func (_Vm *VmCallerSession) GetBlobhashes() ([][32]byte, error) { + return _Vm.Contract.GetBlobhashes(&_Vm.CallOpts) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_Vm *VmCaller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getBlockNumber") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_Vm *VmSession) GetBlockNumber() (*big.Int, error) { + return _Vm.Contract.GetBlockNumber(&_Vm.CallOpts) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_Vm *VmCallerSession) GetBlockNumber() (*big.Int, error) { + return _Vm.Contract.GetBlockNumber(&_Vm.CallOpts) +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_Vm *VmCaller) GetBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getBlockTimestamp") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_Vm *VmSession) GetBlockTimestamp() (*big.Int, error) { + return _Vm.Contract.GetBlockTimestamp(&_Vm.CallOpts) +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_Vm *VmCallerSession) GetBlockTimestamp() (*big.Int, error) { + return _Vm.Contract.GetBlockTimestamp(&_Vm.CallOpts) +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_Vm *VmCaller) GetCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getCode", artifactPath) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_Vm *VmSession) GetCode(artifactPath string) ([]byte, error) { + return _Vm.Contract.GetCode(&_Vm.CallOpts, artifactPath) +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_Vm *VmCallerSession) GetCode(artifactPath string) ([]byte, error) { + return _Vm.Contract.GetCode(&_Vm.CallOpts, artifactPath) +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_Vm *VmCaller) GetDeployedCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getDeployedCode", artifactPath) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_Vm *VmSession) GetDeployedCode(artifactPath string) ([]byte, error) { + return _Vm.Contract.GetDeployedCode(&_Vm.CallOpts, artifactPath) +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_Vm *VmCallerSession) GetDeployedCode(artifactPath string) ([]byte, error) { + return _Vm.Contract.GetDeployedCode(&_Vm.CallOpts, artifactPath) +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_Vm *VmCaller) GetLabel(opts *bind.CallOpts, account common.Address) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getLabel", account) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_Vm *VmSession) GetLabel(account common.Address) (string, error) { + return _Vm.Contract.GetLabel(&_Vm.CallOpts, account) +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_Vm *VmCallerSession) GetLabel(account common.Address) (string, error) { + return _Vm.Contract.GetLabel(&_Vm.CallOpts, account) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_Vm *VmCaller) GetNonce(opts *bind.CallOpts, account common.Address) (uint64, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "getNonce", account) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_Vm *VmSession) GetNonce(account common.Address) (uint64, error) { + return _Vm.Contract.GetNonce(&_Vm.CallOpts, account) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_Vm *VmCallerSession) GetNonce(account common.Address) (uint64, error) { + return _Vm.Contract.GetNonce(&_Vm.CallOpts, account) +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_Vm *VmCaller) IndexOf(opts *bind.CallOpts, input string, key string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "indexOf", input, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_Vm *VmSession) IndexOf(input string, key string) (*big.Int, error) { + return _Vm.Contract.IndexOf(&_Vm.CallOpts, input, key) +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_Vm *VmCallerSession) IndexOf(input string, key string) (*big.Int, error) { + return _Vm.Contract.IndexOf(&_Vm.CallOpts, input, key) +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_Vm *VmCaller) IsContext(opts *bind.CallOpts, context uint8) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "isContext", context) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_Vm *VmSession) IsContext(context uint8) (bool, error) { + return _Vm.Contract.IsContext(&_Vm.CallOpts, context) +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_Vm *VmCallerSession) IsContext(context uint8) (bool, error) { + return _Vm.Contract.IsContext(&_Vm.CallOpts, context) +} + +// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd. +// +// Solidity: function isPersistent(address account) view returns(bool persistent) +func (_Vm *VmCaller) IsPersistent(opts *bind.CallOpts, account common.Address) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "isPersistent", account) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd. +// +// Solidity: function isPersistent(address account) view returns(bool persistent) +func (_Vm *VmSession) IsPersistent(account common.Address) (bool, error) { + return _Vm.Contract.IsPersistent(&_Vm.CallOpts, account) +} + +// IsPersistent is a free data retrieval call binding the contract method 0xd92d8efd. +// +// Solidity: function isPersistent(address account) view returns(bool persistent) +func (_Vm *VmCallerSession) IsPersistent(account common.Address) (bool, error) { + return _Vm.Contract.IsPersistent(&_Vm.CallOpts, account) +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_Vm *VmCaller) KeyExists(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "keyExists", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_Vm *VmSession) KeyExists(json string, key string) (bool, error) { + return _Vm.Contract.KeyExists(&_Vm.CallOpts, json, key) +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_Vm *VmCallerSession) KeyExists(json string, key string) (bool, error) { + return _Vm.Contract.KeyExists(&_Vm.CallOpts, json, key) +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_Vm *VmCaller) KeyExistsJson(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "keyExistsJson", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_Vm *VmSession) KeyExistsJson(json string, key string) (bool, error) { + return _Vm.Contract.KeyExistsJson(&_Vm.CallOpts, json, key) +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_Vm *VmCallerSession) KeyExistsJson(json string, key string) (bool, error) { + return _Vm.Contract.KeyExistsJson(&_Vm.CallOpts, json, key) +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_Vm *VmCaller) KeyExistsToml(opts *bind.CallOpts, toml string, key string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "keyExistsToml", toml, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_Vm *VmSession) KeyExistsToml(toml string, key string) (bool, error) { + return _Vm.Contract.KeyExistsToml(&_Vm.CallOpts, toml, key) +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_Vm *VmCallerSession) KeyExistsToml(toml string, key string) (bool, error) { + return _Vm.Contract.KeyExistsToml(&_Vm.CallOpts, toml, key) +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_Vm *VmCaller) LastCallGas(opts *bind.CallOpts) (VmSafeGas, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "lastCallGas") + + if err != nil { + return *new(VmSafeGas), err + } + + out0 := *abi.ConvertType(out[0], new(VmSafeGas)).(*VmSafeGas) + + return out0, err + +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_Vm *VmSession) LastCallGas() (VmSafeGas, error) { + return _Vm.Contract.LastCallGas(&_Vm.CallOpts) +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_Vm *VmCallerSession) LastCallGas() (VmSafeGas, error) { + return _Vm.Contract.LastCallGas(&_Vm.CallOpts) +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_Vm *VmCaller) Load(opts *bind.CallOpts, target common.Address, slot [32]byte) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "load", target, slot) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_Vm *VmSession) Load(target common.Address, slot [32]byte) ([32]byte, error) { + return _Vm.Contract.Load(&_Vm.CallOpts, target, slot) +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_Vm *VmCallerSession) Load(target common.Address, slot [32]byte) ([32]byte, error) { + return _Vm.Contract.Load(&_Vm.CallOpts, target, slot) +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_Vm *VmCaller) ParseAddress(opts *bind.CallOpts, stringifiedValue string) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseAddress", stringifiedValue) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_Vm *VmSession) ParseAddress(stringifiedValue string) (common.Address, error) { + return _Vm.Contract.ParseAddress(&_Vm.CallOpts, stringifiedValue) +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_Vm *VmCallerSession) ParseAddress(stringifiedValue string) (common.Address, error) { + return _Vm.Contract.ParseAddress(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_Vm *VmCaller) ParseBool(opts *bind.CallOpts, stringifiedValue string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseBool", stringifiedValue) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_Vm *VmSession) ParseBool(stringifiedValue string) (bool, error) { + return _Vm.Contract.ParseBool(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_Vm *VmCallerSession) ParseBool(stringifiedValue string) (bool, error) { + return _Vm.Contract.ParseBool(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_Vm *VmCaller) ParseBytes(opts *bind.CallOpts, stringifiedValue string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseBytes", stringifiedValue) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_Vm *VmSession) ParseBytes(stringifiedValue string) ([]byte, error) { + return _Vm.Contract.ParseBytes(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_Vm *VmCallerSession) ParseBytes(stringifiedValue string) ([]byte, error) { + return _Vm.Contract.ParseBytes(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_Vm *VmCaller) ParseBytes32(opts *bind.CallOpts, stringifiedValue string) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseBytes32", stringifiedValue) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_Vm *VmSession) ParseBytes32(stringifiedValue string) ([32]byte, error) { + return _Vm.Contract.ParseBytes32(&_Vm.CallOpts, stringifiedValue) +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_Vm *VmCallerSession) ParseBytes32(stringifiedValue string) ([32]byte, error) { + return _Vm.Contract.ParseBytes32(&_Vm.CallOpts, stringifiedValue) +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_Vm *VmCaller) ParseInt(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseInt", stringifiedValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_Vm *VmSession) ParseInt(stringifiedValue string) (*big.Int, error) { + return _Vm.Contract.ParseInt(&_Vm.CallOpts, stringifiedValue) +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_Vm *VmCallerSession) ParseInt(stringifiedValue string) (*big.Int, error) { + return _Vm.Contract.ParseInt(&_Vm.CallOpts, stringifiedValue) +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_Vm *VmCaller) ParseJson(opts *bind.CallOpts, json string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJson", json) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_Vm *VmSession) ParseJson(json string) ([]byte, error) { + return _Vm.Contract.ParseJson(&_Vm.CallOpts, json) +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_Vm *VmCallerSession) ParseJson(json string) ([]byte, error) { + return _Vm.Contract.ParseJson(&_Vm.CallOpts, json) +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmCaller) ParseJson0(opts *bind.CallOpts, json string, key string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJson0", json, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmSession) ParseJson0(json string, key string) ([]byte, error) { + return _Vm.Contract.ParseJson0(&_Vm.CallOpts, json, key) +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmCallerSession) ParseJson0(json string, key string) ([]byte, error) { + return _Vm.Contract.ParseJson0(&_Vm.CallOpts, json, key) +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_Vm *VmCaller) ParseJsonAddress(opts *bind.CallOpts, json string, key string) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonAddress", json, key) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_Vm *VmSession) ParseJsonAddress(json string, key string) (common.Address, error) { + return _Vm.Contract.ParseJsonAddress(&_Vm.CallOpts, json, key) +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_Vm *VmCallerSession) ParseJsonAddress(json string, key string) (common.Address, error) { + return _Vm.Contract.ParseJsonAddress(&_Vm.CallOpts, json, key) +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_Vm *VmCaller) ParseJsonAddressArray(opts *bind.CallOpts, json string, key string) ([]common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonAddressArray", json, key) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_Vm *VmSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) { + return _Vm.Contract.ParseJsonAddressArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_Vm *VmCallerSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) { + return _Vm.Contract.ParseJsonAddressArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_Vm *VmCaller) ParseJsonBool(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBool", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_Vm *VmSession) ParseJsonBool(json string, key string) (bool, error) { + return _Vm.Contract.ParseJsonBool(&_Vm.CallOpts, json, key) +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_Vm *VmCallerSession) ParseJsonBool(json string, key string) (bool, error) { + return _Vm.Contract.ParseJsonBool(&_Vm.CallOpts, json, key) +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_Vm *VmCaller) ParseJsonBoolArray(opts *bind.CallOpts, json string, key string) ([]bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBoolArray", json, key) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_Vm *VmSession) ParseJsonBoolArray(json string, key string) ([]bool, error) { + return _Vm.Contract.ParseJsonBoolArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_Vm *VmCallerSession) ParseJsonBoolArray(json string, key string) ([]bool, error) { + return _Vm.Contract.ParseJsonBoolArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_Vm *VmCaller) ParseJsonBytes(opts *bind.CallOpts, json string, key string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBytes", json, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_Vm *VmSession) ParseJsonBytes(json string, key string) ([]byte, error) { + return _Vm.Contract.ParseJsonBytes(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_Vm *VmCallerSession) ParseJsonBytes(json string, key string) ([]byte, error) { + return _Vm.Contract.ParseJsonBytes(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_Vm *VmCaller) ParseJsonBytes32(opts *bind.CallOpts, json string, key string) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBytes32", json, key) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_Vm *VmSession) ParseJsonBytes32(json string, key string) ([32]byte, error) { + return _Vm.Contract.ParseJsonBytes32(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_Vm *VmCallerSession) ParseJsonBytes32(json string, key string) ([32]byte, error) { + return _Vm.Contract.ParseJsonBytes32(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_Vm *VmCaller) ParseJsonBytes32Array(opts *bind.CallOpts, json string, key string) ([][32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBytes32Array", json, key) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_Vm *VmSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) { + return _Vm.Contract.ParseJsonBytes32Array(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_Vm *VmCallerSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) { + return _Vm.Contract.ParseJsonBytes32Array(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_Vm *VmCaller) ParseJsonBytesArray(opts *bind.CallOpts, json string, key string) ([][]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonBytesArray", json, key) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_Vm *VmSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) { + return _Vm.Contract.ParseJsonBytesArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_Vm *VmCallerSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) { + return _Vm.Contract.ParseJsonBytesArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_Vm *VmCaller) ParseJsonInt(opts *bind.CallOpts, json string, key string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonInt", json, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_Vm *VmSession) ParseJsonInt(json string, key string) (*big.Int, error) { + return _Vm.Contract.ParseJsonInt(&_Vm.CallOpts, json, key) +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_Vm *VmCallerSession) ParseJsonInt(json string, key string) (*big.Int, error) { + return _Vm.Contract.ParseJsonInt(&_Vm.CallOpts, json, key) +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_Vm *VmCaller) ParseJsonIntArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonIntArray", json, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_Vm *VmSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseJsonIntArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_Vm *VmCallerSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseJsonIntArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_Vm *VmCaller) ParseJsonKeys(opts *bind.CallOpts, json string, key string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonKeys", json, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_Vm *VmSession) ParseJsonKeys(json string, key string) ([]string, error) { + return _Vm.Contract.ParseJsonKeys(&_Vm.CallOpts, json, key) +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_Vm *VmCallerSession) ParseJsonKeys(json string, key string) ([]string, error) { + return _Vm.Contract.ParseJsonKeys(&_Vm.CallOpts, json, key) +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_Vm *VmCaller) ParseJsonString(opts *bind.CallOpts, json string, key string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonString", json, key) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_Vm *VmSession) ParseJsonString(json string, key string) (string, error) { + return _Vm.Contract.ParseJsonString(&_Vm.CallOpts, json, key) +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_Vm *VmCallerSession) ParseJsonString(json string, key string) (string, error) { + return _Vm.Contract.ParseJsonString(&_Vm.CallOpts, json, key) +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_Vm *VmCaller) ParseJsonStringArray(opts *bind.CallOpts, json string, key string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonStringArray", json, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_Vm *VmSession) ParseJsonStringArray(json string, key string) ([]string, error) { + return _Vm.Contract.ParseJsonStringArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_Vm *VmCallerSession) ParseJsonStringArray(json string, key string) ([]string, error) { + return _Vm.Contract.ParseJsonStringArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_Vm *VmCaller) ParseJsonUint(opts *bind.CallOpts, json string, key string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonUint", json, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_Vm *VmSession) ParseJsonUint(json string, key string) (*big.Int, error) { + return _Vm.Contract.ParseJsonUint(&_Vm.CallOpts, json, key) +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_Vm *VmCallerSession) ParseJsonUint(json string, key string) (*big.Int, error) { + return _Vm.Contract.ParseJsonUint(&_Vm.CallOpts, json, key) +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_Vm *VmCaller) ParseJsonUintArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseJsonUintArray", json, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_Vm *VmSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseJsonUintArray(&_Vm.CallOpts, json, key) +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_Vm *VmCallerSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseJsonUintArray(&_Vm.CallOpts, json, key) +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmCaller) ParseToml(opts *bind.CallOpts, toml string, key string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseToml", toml, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmSession) ParseToml(toml string, key string) ([]byte, error) { + return _Vm.Contract.ParseToml(&_Vm.CallOpts, toml, key) +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_Vm *VmCallerSession) ParseToml(toml string, key string) ([]byte, error) { + return _Vm.Contract.ParseToml(&_Vm.CallOpts, toml, key) +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_Vm *VmCaller) ParseToml0(opts *bind.CallOpts, toml string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseToml0", toml) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_Vm *VmSession) ParseToml0(toml string) ([]byte, error) { + return _Vm.Contract.ParseToml0(&_Vm.CallOpts, toml) +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_Vm *VmCallerSession) ParseToml0(toml string) ([]byte, error) { + return _Vm.Contract.ParseToml0(&_Vm.CallOpts, toml) +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_Vm *VmCaller) ParseTomlAddress(opts *bind.CallOpts, toml string, key string) (common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlAddress", toml, key) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_Vm *VmSession) ParseTomlAddress(toml string, key string) (common.Address, error) { + return _Vm.Contract.ParseTomlAddress(&_Vm.CallOpts, toml, key) +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_Vm *VmCallerSession) ParseTomlAddress(toml string, key string) (common.Address, error) { + return _Vm.Contract.ParseTomlAddress(&_Vm.CallOpts, toml, key) +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_Vm *VmCaller) ParseTomlAddressArray(opts *bind.CallOpts, toml string, key string) ([]common.Address, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlAddressArray", toml, key) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_Vm *VmSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) { + return _Vm.Contract.ParseTomlAddressArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_Vm *VmCallerSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) { + return _Vm.Contract.ParseTomlAddressArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_Vm *VmCaller) ParseTomlBool(opts *bind.CallOpts, toml string, key string) (bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBool", toml, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_Vm *VmSession) ParseTomlBool(toml string, key string) (bool, error) { + return _Vm.Contract.ParseTomlBool(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_Vm *VmCallerSession) ParseTomlBool(toml string, key string) (bool, error) { + return _Vm.Contract.ParseTomlBool(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_Vm *VmCaller) ParseTomlBoolArray(opts *bind.CallOpts, toml string, key string) ([]bool, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBoolArray", toml, key) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_Vm *VmSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) { + return _Vm.Contract.ParseTomlBoolArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_Vm *VmCallerSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) { + return _Vm.Contract.ParseTomlBoolArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_Vm *VmCaller) ParseTomlBytes(opts *bind.CallOpts, toml string, key string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBytes", toml, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_Vm *VmSession) ParseTomlBytes(toml string, key string) ([]byte, error) { + return _Vm.Contract.ParseTomlBytes(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_Vm *VmCallerSession) ParseTomlBytes(toml string, key string) ([]byte, error) { + return _Vm.Contract.ParseTomlBytes(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_Vm *VmCaller) ParseTomlBytes32(opts *bind.CallOpts, toml string, key string) ([32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBytes32", toml, key) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_Vm *VmSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) { + return _Vm.Contract.ParseTomlBytes32(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_Vm *VmCallerSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) { + return _Vm.Contract.ParseTomlBytes32(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_Vm *VmCaller) ParseTomlBytes32Array(opts *bind.CallOpts, toml string, key string) ([][32]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBytes32Array", toml, key) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_Vm *VmSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) { + return _Vm.Contract.ParseTomlBytes32Array(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_Vm *VmCallerSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) { + return _Vm.Contract.ParseTomlBytes32Array(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_Vm *VmCaller) ParseTomlBytesArray(opts *bind.CallOpts, toml string, key string) ([][]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlBytesArray", toml, key) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_Vm *VmSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) { + return _Vm.Contract.ParseTomlBytesArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_Vm *VmCallerSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) { + return _Vm.Contract.ParseTomlBytesArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_Vm *VmCaller) ParseTomlInt(opts *bind.CallOpts, toml string, key string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlInt", toml, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_Vm *VmSession) ParseTomlInt(toml string, key string) (*big.Int, error) { + return _Vm.Contract.ParseTomlInt(&_Vm.CallOpts, toml, key) +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_Vm *VmCallerSession) ParseTomlInt(toml string, key string) (*big.Int, error) { + return _Vm.Contract.ParseTomlInt(&_Vm.CallOpts, toml, key) +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_Vm *VmCaller) ParseTomlIntArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlIntArray", toml, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_Vm *VmSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseTomlIntArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_Vm *VmCallerSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseTomlIntArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_Vm *VmCaller) ParseTomlKeys(opts *bind.CallOpts, toml string, key string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlKeys", toml, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_Vm *VmSession) ParseTomlKeys(toml string, key string) ([]string, error) { + return _Vm.Contract.ParseTomlKeys(&_Vm.CallOpts, toml, key) +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_Vm *VmCallerSession) ParseTomlKeys(toml string, key string) ([]string, error) { + return _Vm.Contract.ParseTomlKeys(&_Vm.CallOpts, toml, key) +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_Vm *VmCaller) ParseTomlString(opts *bind.CallOpts, toml string, key string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlString", toml, key) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_Vm *VmSession) ParseTomlString(toml string, key string) (string, error) { + return _Vm.Contract.ParseTomlString(&_Vm.CallOpts, toml, key) +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_Vm *VmCallerSession) ParseTomlString(toml string, key string) (string, error) { + return _Vm.Contract.ParseTomlString(&_Vm.CallOpts, toml, key) +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_Vm *VmCaller) ParseTomlStringArray(opts *bind.CallOpts, toml string, key string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlStringArray", toml, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_Vm *VmSession) ParseTomlStringArray(toml string, key string) ([]string, error) { + return _Vm.Contract.ParseTomlStringArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_Vm *VmCallerSession) ParseTomlStringArray(toml string, key string) ([]string, error) { + return _Vm.Contract.ParseTomlStringArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_Vm *VmCaller) ParseTomlUint(opts *bind.CallOpts, toml string, key string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlUint", toml, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_Vm *VmSession) ParseTomlUint(toml string, key string) (*big.Int, error) { + return _Vm.Contract.ParseTomlUint(&_Vm.CallOpts, toml, key) +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_Vm *VmCallerSession) ParseTomlUint(toml string, key string) (*big.Int, error) { + return _Vm.Contract.ParseTomlUint(&_Vm.CallOpts, toml, key) +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_Vm *VmCaller) ParseTomlUintArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseTomlUintArray", toml, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_Vm *VmSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseTomlUintArray(&_Vm.CallOpts, toml, key) +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_Vm *VmCallerSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) { + return _Vm.Contract.ParseTomlUintArray(&_Vm.CallOpts, toml, key) +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_Vm *VmCaller) ParseUint(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "parseUint", stringifiedValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_Vm *VmSession) ParseUint(stringifiedValue string) (*big.Int, error) { + return _Vm.Contract.ParseUint(&_Vm.CallOpts, stringifiedValue) +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_Vm *VmCallerSession) ParseUint(stringifiedValue string) (*big.Int, error) { + return _Vm.Contract.ParseUint(&_Vm.CallOpts, stringifiedValue) +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_Vm *VmCaller) ProjectRoot(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "projectRoot") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_Vm *VmSession) ProjectRoot() (string, error) { + return _Vm.Contract.ProjectRoot(&_Vm.CallOpts) +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_Vm *VmCallerSession) ProjectRoot() (string, error) { + return _Vm.Contract.ProjectRoot(&_Vm.CallOpts) +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCaller) ReadDir(opts *bind.CallOpts, path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readDir", path, maxDepth) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir(&_Vm.CallOpts, path, maxDepth) +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCallerSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir(&_Vm.CallOpts, path, maxDepth) +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCaller) ReadDir0(opts *bind.CallOpts, path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readDir0", path, maxDepth, followLinks) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir0(&_Vm.CallOpts, path, maxDepth, followLinks) +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCallerSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir0(&_Vm.CallOpts, path, maxDepth, followLinks) +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCaller) ReadDir1(opts *bind.CallOpts, path string) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readDir1", path) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmSession) ReadDir1(path string) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir1(&_Vm.CallOpts, path) +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_Vm *VmCallerSession) ReadDir1(path string) ([]VmSafeDirEntry, error) { + return _Vm.Contract.ReadDir1(&_Vm.CallOpts, path) +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_Vm *VmCaller) ReadFile(opts *bind.CallOpts, path string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readFile", path) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_Vm *VmSession) ReadFile(path string) (string, error) { + return _Vm.Contract.ReadFile(&_Vm.CallOpts, path) +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_Vm *VmCallerSession) ReadFile(path string) (string, error) { + return _Vm.Contract.ReadFile(&_Vm.CallOpts, path) +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_Vm *VmCaller) ReadFileBinary(opts *bind.CallOpts, path string) ([]byte, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readFileBinary", path) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_Vm *VmSession) ReadFileBinary(path string) ([]byte, error) { + return _Vm.Contract.ReadFileBinary(&_Vm.CallOpts, path) +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_Vm *VmCallerSession) ReadFileBinary(path string) ([]byte, error) { + return _Vm.Contract.ReadFileBinary(&_Vm.CallOpts, path) +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_Vm *VmCaller) ReadLine(opts *bind.CallOpts, path string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readLine", path) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_Vm *VmSession) ReadLine(path string) (string, error) { + return _Vm.Contract.ReadLine(&_Vm.CallOpts, path) +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_Vm *VmCallerSession) ReadLine(path string) (string, error) { + return _Vm.Contract.ReadLine(&_Vm.CallOpts, path) +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_Vm *VmCaller) ReadLink(opts *bind.CallOpts, linkPath string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "readLink", linkPath) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_Vm *VmSession) ReadLink(linkPath string) (string, error) { + return _Vm.Contract.ReadLink(&_Vm.CallOpts, linkPath) +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_Vm *VmCallerSession) ReadLink(linkPath string) (string, error) { + return _Vm.Contract.ReadLink(&_Vm.CallOpts, linkPath) +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_Vm *VmCaller) Replace(opts *bind.CallOpts, input string, from string, to string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "replace", input, from, to) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_Vm *VmSession) Replace(input string, from string, to string) (string, error) { + return _Vm.Contract.Replace(&_Vm.CallOpts, input, from, to) +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_Vm *VmCallerSession) Replace(input string, from string, to string) (string, error) { + return _Vm.Contract.Replace(&_Vm.CallOpts, input, from, to) +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_Vm *VmCaller) RpcUrl(opts *bind.CallOpts, rpcAlias string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "rpcUrl", rpcAlias) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_Vm *VmSession) RpcUrl(rpcAlias string) (string, error) { + return _Vm.Contract.RpcUrl(&_Vm.CallOpts, rpcAlias) +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_Vm *VmCallerSession) RpcUrl(rpcAlias string) (string, error) { + return _Vm.Contract.RpcUrl(&_Vm.CallOpts, rpcAlias) +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_Vm *VmCaller) RpcUrlStructs(opts *bind.CallOpts) ([]VmSafeRpc, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "rpcUrlStructs") + + if err != nil { + return *new([]VmSafeRpc), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeRpc)).(*[]VmSafeRpc) + + return out0, err + +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_Vm *VmSession) RpcUrlStructs() ([]VmSafeRpc, error) { + return _Vm.Contract.RpcUrlStructs(&_Vm.CallOpts) +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_Vm *VmCallerSession) RpcUrlStructs() ([]VmSafeRpc, error) { + return _Vm.Contract.RpcUrlStructs(&_Vm.CallOpts) +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_Vm *VmCaller) RpcUrls(opts *bind.CallOpts) ([][2]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "rpcUrls") + + if err != nil { + return *new([][2]string), err + } + + out0 := *abi.ConvertType(out[0], new([][2]string)).(*[][2]string) + + return out0, err + +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_Vm *VmSession) RpcUrls() ([][2]string, error) { + return _Vm.Contract.RpcUrls(&_Vm.CallOpts) +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_Vm *VmCallerSession) RpcUrls() ([][2]string, error) { + return _Vm.Contract.RpcUrls(&_Vm.CallOpts) +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCaller) Sign(opts *bind.CallOpts, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "sign", digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmSession) Sign(digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign(&_Vm.CallOpts, digest) +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCallerSession) Sign(digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign(&_Vm.CallOpts, digest) +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCaller) Sign0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "sign0", signer, digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmSession) Sign0(signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign0(&_Vm.CallOpts, signer, digest) +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCallerSession) Sign0(signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign0(&_Vm.CallOpts, signer, digest) +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCaller) Sign2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "sign2", privateKey, digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmSession) Sign2(privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign2(&_Vm.CallOpts, privateKey, digest) +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmCallerSession) Sign2(privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.Sign2(&_Vm.CallOpts, privateKey, digest) +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_Vm *VmCaller) SignP256(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "signP256", privateKey, digest) + + outstruct := new(struct { + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_Vm *VmSession) SignP256(privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.SignP256(&_Vm.CallOpts, privateKey, digest) +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_Vm *VmCallerSession) SignP256(privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + return _Vm.Contract.SignP256(&_Vm.CallOpts, privateKey, digest) +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_Vm *VmCaller) Split(opts *bind.CallOpts, input string, delimiter string) ([]string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "split", input, delimiter) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_Vm *VmSession) Split(input string, delimiter string) ([]string, error) { + return _Vm.Contract.Split(&_Vm.CallOpts, input, delimiter) +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_Vm *VmCallerSession) Split(input string, delimiter string) ([]string, error) { + return _Vm.Contract.Split(&_Vm.CallOpts, input, delimiter) +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_Vm *VmCaller) ToBase64(opts *bind.CallOpts, data string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toBase64", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_Vm *VmSession) ToBase64(data string) (string, error) { + return _Vm.Contract.ToBase64(&_Vm.CallOpts, data) +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_Vm *VmCallerSession) ToBase64(data string) (string, error) { + return _Vm.Contract.ToBase64(&_Vm.CallOpts, data) +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_Vm *VmCaller) ToBase640(opts *bind.CallOpts, data []byte) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toBase640", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_Vm *VmSession) ToBase640(data []byte) (string, error) { + return _Vm.Contract.ToBase640(&_Vm.CallOpts, data) +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_Vm *VmCallerSession) ToBase640(data []byte) (string, error) { + return _Vm.Contract.ToBase640(&_Vm.CallOpts, data) +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_Vm *VmCaller) ToBase64URL(opts *bind.CallOpts, data string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toBase64URL", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_Vm *VmSession) ToBase64URL(data string) (string, error) { + return _Vm.Contract.ToBase64URL(&_Vm.CallOpts, data) +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_Vm *VmCallerSession) ToBase64URL(data string) (string, error) { + return _Vm.Contract.ToBase64URL(&_Vm.CallOpts, data) +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_Vm *VmCaller) ToBase64URL0(opts *bind.CallOpts, data []byte) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toBase64URL0", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_Vm *VmSession) ToBase64URL0(data []byte) (string, error) { + return _Vm.Contract.ToBase64URL0(&_Vm.CallOpts, data) +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_Vm *VmCallerSession) ToBase64URL0(data []byte) (string, error) { + return _Vm.Contract.ToBase64URL0(&_Vm.CallOpts, data) +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_Vm *VmCaller) ToLowercase(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toLowercase", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_Vm *VmSession) ToLowercase(input string) (string, error) { + return _Vm.Contract.ToLowercase(&_Vm.CallOpts, input) +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_Vm *VmCallerSession) ToLowercase(input string) (string, error) { + return _Vm.Contract.ToLowercase(&_Vm.CallOpts, input) +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString(opts *bind.CallOpts, value common.Address) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString(value common.Address) (string, error) { + return _Vm.Contract.ToString(&_Vm.CallOpts, value) +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString(value common.Address) (string, error) { + return _Vm.Contract.ToString(&_Vm.CallOpts, value) +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString0(opts *bind.CallOpts, value *big.Int) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString0", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString0(value *big.Int) (string, error) { + return _Vm.Contract.ToString0(&_Vm.CallOpts, value) +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString0(value *big.Int) (string, error) { + return _Vm.Contract.ToString0(&_Vm.CallOpts, value) +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString1(opts *bind.CallOpts, value []byte) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString1", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString1(value []byte) (string, error) { + return _Vm.Contract.ToString1(&_Vm.CallOpts, value) +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString1(value []byte) (string, error) { + return _Vm.Contract.ToString1(&_Vm.CallOpts, value) +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString2(opts *bind.CallOpts, value bool) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString2", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString2(value bool) (string, error) { + return _Vm.Contract.ToString2(&_Vm.CallOpts, value) +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString2(value bool) (string, error) { + return _Vm.Contract.ToString2(&_Vm.CallOpts, value) +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString3(opts *bind.CallOpts, value *big.Int) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString3", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString3(value *big.Int) (string, error) { + return _Vm.Contract.ToString3(&_Vm.CallOpts, value) +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString3(value *big.Int) (string, error) { + return _Vm.Contract.ToString3(&_Vm.CallOpts, value) +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_Vm *VmCaller) ToString4(opts *bind.CallOpts, value [32]byte) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toString4", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_Vm *VmSession) ToString4(value [32]byte) (string, error) { + return _Vm.Contract.ToString4(&_Vm.CallOpts, value) +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_Vm *VmCallerSession) ToString4(value [32]byte) (string, error) { + return _Vm.Contract.ToString4(&_Vm.CallOpts, value) +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_Vm *VmCaller) ToUppercase(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "toUppercase", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_Vm *VmSession) ToUppercase(input string) (string, error) { + return _Vm.Contract.ToUppercase(&_Vm.CallOpts, input) +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_Vm *VmCallerSession) ToUppercase(input string) (string, error) { + return _Vm.Contract.ToUppercase(&_Vm.CallOpts, input) +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_Vm *VmCaller) Trim(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _Vm.contract.Call(opts, &out, "trim", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_Vm *VmSession) Trim(input string) (string, error) { + return _Vm.Contract.Trim(&_Vm.CallOpts, input) +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_Vm *VmCallerSession) Trim(input string) (string, error) { + return _Vm.Contract.Trim(&_Vm.CallOpts, input) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_Vm *VmTransactor) Accesses(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "accesses", target) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_Vm *VmSession) Accesses(target common.Address) (*types.Transaction, error) { + return _Vm.Contract.Accesses(&_Vm.TransactOpts, target) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_Vm *VmTransactorSession) Accesses(target common.Address) (*types.Transaction, error) { + return _Vm.Contract.Accesses(&_Vm.TransactOpts, target) +} + +// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291. +// +// Solidity: function allowCheatcodes(address account) returns() +func (_Vm *VmTransactor) AllowCheatcodes(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "allowCheatcodes", account) +} + +// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291. +// +// Solidity: function allowCheatcodes(address account) returns() +func (_Vm *VmSession) AllowCheatcodes(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.AllowCheatcodes(&_Vm.TransactOpts, account) +} + +// AllowCheatcodes is a paid mutator transaction binding the contract method 0xea060291. +// +// Solidity: function allowCheatcodes(address account) returns() +func (_Vm *VmTransactorSession) AllowCheatcodes(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.AllowCheatcodes(&_Vm.TransactOpts, account) +} + +// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e. +// +// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns() +func (_Vm *VmTransactor) BlobBaseFee(opts *bind.TransactOpts, newBlobBaseFee *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "blobBaseFee", newBlobBaseFee) +} + +// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e. +// +// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns() +func (_Vm *VmSession) BlobBaseFee(newBlobBaseFee *big.Int) (*types.Transaction, error) { + return _Vm.Contract.BlobBaseFee(&_Vm.TransactOpts, newBlobBaseFee) +} + +// BlobBaseFee is a paid mutator transaction binding the contract method 0x6d315d7e. +// +// Solidity: function blobBaseFee(uint256 newBlobBaseFee) returns() +func (_Vm *VmTransactorSession) BlobBaseFee(newBlobBaseFee *big.Int) (*types.Transaction, error) { + return _Vm.Contract.BlobBaseFee(&_Vm.TransactOpts, newBlobBaseFee) +} + +// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb. +// +// Solidity: function blobhashes(bytes32[] hashes) returns() +func (_Vm *VmTransactor) Blobhashes(opts *bind.TransactOpts, hashes [][32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "blobhashes", hashes) +} + +// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb. +// +// Solidity: function blobhashes(bytes32[] hashes) returns() +func (_Vm *VmSession) Blobhashes(hashes [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.Blobhashes(&_Vm.TransactOpts, hashes) +} + +// Blobhashes is a paid mutator transaction binding the contract method 0x129de7eb. +// +// Solidity: function blobhashes(bytes32[] hashes) returns() +func (_Vm *VmTransactorSession) Blobhashes(hashes [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.Blobhashes(&_Vm.TransactOpts, hashes) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_Vm *VmTransactor) Breakpoint(opts *bind.TransactOpts, char string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "breakpoint", char) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_Vm *VmSession) Breakpoint(char string) (*types.Transaction, error) { + return _Vm.Contract.Breakpoint(&_Vm.TransactOpts, char) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_Vm *VmTransactorSession) Breakpoint(char string) (*types.Transaction, error) { + return _Vm.Contract.Breakpoint(&_Vm.TransactOpts, char) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_Vm *VmTransactor) Breakpoint0(opts *bind.TransactOpts, char string, value bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "breakpoint0", char, value) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_Vm *VmSession) Breakpoint0(char string, value bool) (*types.Transaction, error) { + return _Vm.Contract.Breakpoint0(&_Vm.TransactOpts, char, value) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_Vm *VmTransactorSession) Breakpoint0(char string, value bool) (*types.Transaction, error) { + return _Vm.Contract.Breakpoint0(&_Vm.TransactOpts, char, value) +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_Vm *VmTransactor) Broadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "broadcast") +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_Vm *VmSession) Broadcast() (*types.Transaction, error) { + return _Vm.Contract.Broadcast(&_Vm.TransactOpts) +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_Vm *VmTransactorSession) Broadcast() (*types.Transaction, error) { + return _Vm.Contract.Broadcast(&_Vm.TransactOpts) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_Vm *VmTransactor) Broadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "broadcast0", signer) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_Vm *VmSession) Broadcast0(signer common.Address) (*types.Transaction, error) { + return _Vm.Contract.Broadcast0(&_Vm.TransactOpts, signer) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_Vm *VmTransactorSession) Broadcast0(signer common.Address) (*types.Transaction, error) { + return _Vm.Contract.Broadcast0(&_Vm.TransactOpts, signer) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_Vm *VmTransactor) Broadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "broadcast1", privateKey) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_Vm *VmSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Broadcast1(&_Vm.TransactOpts, privateKey) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_Vm *VmTransactorSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Broadcast1(&_Vm.TransactOpts, privateKey) +} + +// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2. +// +// Solidity: function chainId(uint256 newChainId) returns() +func (_Vm *VmTransactor) ChainId(opts *bind.TransactOpts, newChainId *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "chainId", newChainId) +} + +// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2. +// +// Solidity: function chainId(uint256 newChainId) returns() +func (_Vm *VmSession) ChainId(newChainId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.ChainId(&_Vm.TransactOpts, newChainId) +} + +// ChainId is a paid mutator transaction binding the contract method 0x4049ddd2. +// +// Solidity: function chainId(uint256 newChainId) returns() +func (_Vm *VmTransactorSession) ChainId(newChainId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.ChainId(&_Vm.TransactOpts, newChainId) +} + +// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15. +// +// Solidity: function clearMockedCalls() returns() +func (_Vm *VmTransactor) ClearMockedCalls(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "clearMockedCalls") +} + +// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15. +// +// Solidity: function clearMockedCalls() returns() +func (_Vm *VmSession) ClearMockedCalls() (*types.Transaction, error) { + return _Vm.Contract.ClearMockedCalls(&_Vm.TransactOpts) +} + +// ClearMockedCalls is a paid mutator transaction binding the contract method 0x3fdf4e15. +// +// Solidity: function clearMockedCalls() returns() +func (_Vm *VmTransactorSession) ClearMockedCalls() (*types.Transaction, error) { + return _Vm.Contract.ClearMockedCalls(&_Vm.TransactOpts) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_Vm *VmTransactor) CloseFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "closeFile", path) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_Vm *VmSession) CloseFile(path string) (*types.Transaction, error) { + return _Vm.Contract.CloseFile(&_Vm.TransactOpts, path) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_Vm *VmTransactorSession) CloseFile(path string) (*types.Transaction, error) { + return _Vm.Contract.CloseFile(&_Vm.TransactOpts, path) +} + +// Coinbase is a paid mutator transaction binding the contract method 0xff483c54. +// +// Solidity: function coinbase(address newCoinbase) returns() +func (_Vm *VmTransactor) Coinbase(opts *bind.TransactOpts, newCoinbase common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "coinbase", newCoinbase) +} + +// Coinbase is a paid mutator transaction binding the contract method 0xff483c54. +// +// Solidity: function coinbase(address newCoinbase) returns() +func (_Vm *VmSession) Coinbase(newCoinbase common.Address) (*types.Transaction, error) { + return _Vm.Contract.Coinbase(&_Vm.TransactOpts, newCoinbase) +} + +// Coinbase is a paid mutator transaction binding the contract method 0xff483c54. +// +// Solidity: function coinbase(address newCoinbase) returns() +func (_Vm *VmTransactorSession) Coinbase(newCoinbase common.Address) (*types.Transaction, error) { + return _Vm.Contract.Coinbase(&_Vm.TransactOpts, newCoinbase) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_Vm *VmTransactor) CopyFile(opts *bind.TransactOpts, from string, to string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "copyFile", from, to) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_Vm *VmSession) CopyFile(from string, to string) (*types.Transaction, error) { + return _Vm.Contract.CopyFile(&_Vm.TransactOpts, from, to) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_Vm *VmTransactorSession) CopyFile(from string, to string) (*types.Transaction, error) { + return _Vm.Contract.CopyFile(&_Vm.TransactOpts, from, to) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_Vm *VmTransactor) CreateDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createDir", path, recursive) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_Vm *VmSession) CreateDir(path string, recursive bool) (*types.Transaction, error) { + return _Vm.Contract.CreateDir(&_Vm.TransactOpts, path, recursive) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_Vm *VmTransactorSession) CreateDir(path string, recursive bool) (*types.Transaction, error) { + return _Vm.Contract.CreateDir(&_Vm.TransactOpts, path, recursive) +} + +// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498. +// +// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateFork(opts *bind.TransactOpts, urlOrAlias string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createFork", urlOrAlias) +} + +// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498. +// +// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmSession) CreateFork(urlOrAlias string) (*types.Transaction, error) { + return _Vm.Contract.CreateFork(&_Vm.TransactOpts, urlOrAlias) +} + +// CreateFork is a paid mutator transaction binding the contract method 0x31ba3498. +// +// Solidity: function createFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateFork(urlOrAlias string) (*types.Transaction, error) { + return _Vm.Contract.CreateFork(&_Vm.TransactOpts, urlOrAlias) +} + +// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b. +// +// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateFork0(opts *bind.TransactOpts, urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createFork0", urlOrAlias, blockNumber) +} + +// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b. +// +// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmSession) CreateFork0(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateFork0(&_Vm.TransactOpts, urlOrAlias, blockNumber) +} + +// CreateFork0 is a paid mutator transaction binding the contract method 0x6ba3ba2b. +// +// Solidity: function createFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateFork0(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateFork0(&_Vm.TransactOpts, urlOrAlias, blockNumber) +} + +// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682. +// +// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateFork1(opts *bind.TransactOpts, urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createFork1", urlOrAlias, txHash) +} + +// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682. +// +// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmSession) CreateFork1(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.CreateFork1(&_Vm.TransactOpts, urlOrAlias, txHash) +} + +// CreateFork1 is a paid mutator transaction binding the contract method 0x7ca29682. +// +// Solidity: function createFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateFork1(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.CreateFork1(&_Vm.TransactOpts, urlOrAlias, txHash) +} + +// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d. +// +// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateSelectFork(opts *bind.TransactOpts, urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createSelectFork", urlOrAlias, blockNumber) +} + +// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d. +// +// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmSession) CreateSelectFork(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork(&_Vm.TransactOpts, urlOrAlias, blockNumber) +} + +// CreateSelectFork is a paid mutator transaction binding the contract method 0x71ee464d. +// +// Solidity: function createSelectFork(string urlOrAlias, uint256 blockNumber) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateSelectFork(urlOrAlias string, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork(&_Vm.TransactOpts, urlOrAlias, blockNumber) +} + +// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a. +// +// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateSelectFork0(opts *bind.TransactOpts, urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createSelectFork0", urlOrAlias, txHash) +} + +// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a. +// +// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmSession) CreateSelectFork0(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork0(&_Vm.TransactOpts, urlOrAlias, txHash) +} + +// CreateSelectFork0 is a paid mutator transaction binding the contract method 0x84d52b7a. +// +// Solidity: function createSelectFork(string urlOrAlias, bytes32 txHash) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateSelectFork0(urlOrAlias string, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork0(&_Vm.TransactOpts, urlOrAlias, txHash) +} + +// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034. +// +// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmTransactor) CreateSelectFork1(opts *bind.TransactOpts, urlOrAlias string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createSelectFork1", urlOrAlias) +} + +// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034. +// +// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmSession) CreateSelectFork1(urlOrAlias string) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork1(&_Vm.TransactOpts, urlOrAlias) +} + +// CreateSelectFork1 is a paid mutator transaction binding the contract method 0x98680034. +// +// Solidity: function createSelectFork(string urlOrAlias) returns(uint256 forkId) +func (_Vm *VmTransactorSession) CreateSelectFork1(urlOrAlias string) (*types.Transaction, error) { + return _Vm.Contract.CreateSelectFork1(&_Vm.TransactOpts, urlOrAlias) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactor) CreateWallet(opts *bind.TransactOpts, walletLabel string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createWallet", walletLabel) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmSession) CreateWallet(walletLabel string) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet(&_Vm.TransactOpts, walletLabel) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactorSession) CreateWallet(walletLabel string) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet(&_Vm.TransactOpts, walletLabel) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactor) CreateWallet0(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createWallet0", privateKey) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet0(&_Vm.TransactOpts, privateKey) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactorSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet0(&_Vm.TransactOpts, privateKey) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactor) CreateWallet1(opts *bind.TransactOpts, privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "createWallet1", privateKey, walletLabel) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet1(&_Vm.TransactOpts, privateKey, walletLabel) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_Vm *VmTransactorSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _Vm.Contract.CreateWallet1(&_Vm.TransactOpts, privateKey, walletLabel) +} + +// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d. +// +// Solidity: function deal(address account, uint256 newBalance) returns() +func (_Vm *VmTransactor) Deal(opts *bind.TransactOpts, account common.Address, newBalance *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "deal", account, newBalance) +} + +// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d. +// +// Solidity: function deal(address account, uint256 newBalance) returns() +func (_Vm *VmSession) Deal(account common.Address, newBalance *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Deal(&_Vm.TransactOpts, account, newBalance) +} + +// Deal is a paid mutator transaction binding the contract method 0xc88a5e6d. +// +// Solidity: function deal(address account, uint256 newBalance) returns() +func (_Vm *VmTransactorSession) Deal(account common.Address, newBalance *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Deal(&_Vm.TransactOpts, account, newBalance) +} + +// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557. +// +// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactor) DeleteSnapshot(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "deleteSnapshot", snapshotId) +} + +// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557. +// +// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success) +func (_Vm *VmSession) DeleteSnapshot(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.DeleteSnapshot(&_Vm.TransactOpts, snapshotId) +} + +// DeleteSnapshot is a paid mutator transaction binding the contract method 0xa6368557. +// +// Solidity: function deleteSnapshot(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactorSession) DeleteSnapshot(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.DeleteSnapshot(&_Vm.TransactOpts, snapshotId) +} + +// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469. +// +// Solidity: function deleteSnapshots() returns() +func (_Vm *VmTransactor) DeleteSnapshots(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "deleteSnapshots") +} + +// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469. +// +// Solidity: function deleteSnapshots() returns() +func (_Vm *VmSession) DeleteSnapshots() (*types.Transaction, error) { + return _Vm.Contract.DeleteSnapshots(&_Vm.TransactOpts) +} + +// DeleteSnapshots is a paid mutator transaction binding the contract method 0x421ae469. +// +// Solidity: function deleteSnapshots() returns() +func (_Vm *VmTransactorSession) DeleteSnapshots() (*types.Transaction, error) { + return _Vm.Contract.DeleteSnapshots(&_Vm.TransactOpts) +} + +// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9. +// +// Solidity: function difficulty(uint256 newDifficulty) returns() +func (_Vm *VmTransactor) Difficulty(opts *bind.TransactOpts, newDifficulty *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "difficulty", newDifficulty) +} + +// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9. +// +// Solidity: function difficulty(uint256 newDifficulty) returns() +func (_Vm *VmSession) Difficulty(newDifficulty *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Difficulty(&_Vm.TransactOpts, newDifficulty) +} + +// Difficulty is a paid mutator transaction binding the contract method 0x46cc92d9. +// +// Solidity: function difficulty(uint256 newDifficulty) returns() +func (_Vm *VmTransactorSession) Difficulty(newDifficulty *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Difficulty(&_Vm.TransactOpts, newDifficulty) +} + +// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f. +// +// Solidity: function dumpState(string pathToStateJson) returns() +func (_Vm *VmTransactor) DumpState(opts *bind.TransactOpts, pathToStateJson string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "dumpState", pathToStateJson) +} + +// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f. +// +// Solidity: function dumpState(string pathToStateJson) returns() +func (_Vm *VmSession) DumpState(pathToStateJson string) (*types.Transaction, error) { + return _Vm.Contract.DumpState(&_Vm.TransactOpts, pathToStateJson) +} + +// DumpState is a paid mutator transaction binding the contract method 0x709ecd3f. +// +// Solidity: function dumpState(string pathToStateJson) returns() +func (_Vm *VmTransactorSession) DumpState(pathToStateJson string) (*types.Transaction, error) { + return _Vm.Contract.DumpState(&_Vm.TransactOpts, pathToStateJson) +} + +// Etch is a paid mutator transaction binding the contract method 0xb4d6c782. +// +// Solidity: function etch(address target, bytes newRuntimeBytecode) returns() +func (_Vm *VmTransactor) Etch(opts *bind.TransactOpts, target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "etch", target, newRuntimeBytecode) +} + +// Etch is a paid mutator transaction binding the contract method 0xb4d6c782. +// +// Solidity: function etch(address target, bytes newRuntimeBytecode) returns() +func (_Vm *VmSession) Etch(target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) { + return _Vm.Contract.Etch(&_Vm.TransactOpts, target, newRuntimeBytecode) +} + +// Etch is a paid mutator transaction binding the contract method 0xb4d6c782. +// +// Solidity: function etch(address target, bytes newRuntimeBytecode) returns() +func (_Vm *VmTransactorSession) Etch(target common.Address, newRuntimeBytecode []byte) (*types.Transaction, error) { + return _Vm.Contract.Etch(&_Vm.TransactOpts, target, newRuntimeBytecode) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_Vm *VmTransactor) EthGetLogs(opts *bind.TransactOpts, fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "eth_getLogs", fromBlock, toBlock, target, topics) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_Vm *VmSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.EthGetLogs(&_Vm.TransactOpts, fromBlock, toBlock, target, topics) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_Vm *VmTransactorSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.EthGetLogs(&_Vm.TransactOpts, fromBlock, toBlock, target, topics) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_Vm *VmTransactor) Exists(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "exists", path) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_Vm *VmSession) Exists(path string) (*types.Transaction, error) { + return _Vm.Contract.Exists(&_Vm.TransactOpts, path) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_Vm *VmTransactorSession) Exists(path string) (*types.Transaction, error) { + return _Vm.Contract.Exists(&_Vm.TransactOpts, path) +} + +// ExpectCall is a paid mutator transaction binding the contract method 0x23361207. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns() +func (_Vm *VmTransactor) ExpectCall(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall", callee, msgValue, gas, data) +} + +// ExpectCall is a paid mutator transaction binding the contract method 0x23361207. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns() +func (_Vm *VmSession) ExpectCall(callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall(&_Vm.TransactOpts, callee, msgValue, gas, data) +} + +// ExpectCall is a paid mutator transaction binding the contract method 0x23361207. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data) returns() +func (_Vm *VmTransactorSession) ExpectCall(callee common.Address, msgValue *big.Int, gas uint64, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall(&_Vm.TransactOpts, callee, msgValue, gas, data) +} + +// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns() +func (_Vm *VmTransactor) ExpectCall0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall0", callee, msgValue, gas, data, count) +} + +// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns() +func (_Vm *VmSession) ExpectCall0(callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall0(&_Vm.TransactOpts, callee, msgValue, gas, data, count) +} + +// ExpectCall0 is a paid mutator transaction binding the contract method 0x65b7b7cc. +// +// Solidity: function expectCall(address callee, uint256 msgValue, uint64 gas, bytes data, uint64 count) returns() +func (_Vm *VmTransactorSession) ExpectCall0(callee common.Address, msgValue *big.Int, gas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall0(&_Vm.TransactOpts, callee, msgValue, gas, data, count) +} + +// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns() +func (_Vm *VmTransactor) ExpectCall1(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall1", callee, msgValue, data, count) +} + +// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns() +func (_Vm *VmSession) ExpectCall1(callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall1(&_Vm.TransactOpts, callee, msgValue, data, count) +} + +// ExpectCall1 is a paid mutator transaction binding the contract method 0xa2b1a1ae. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data, uint64 count) returns() +func (_Vm *VmTransactorSession) ExpectCall1(callee common.Address, msgValue *big.Int, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall1(&_Vm.TransactOpts, callee, msgValue, data, count) +} + +// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434. +// +// Solidity: function expectCall(address callee, bytes data) returns() +func (_Vm *VmTransactor) ExpectCall2(opts *bind.TransactOpts, callee common.Address, data []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall2", callee, data) +} + +// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434. +// +// Solidity: function expectCall(address callee, bytes data) returns() +func (_Vm *VmSession) ExpectCall2(callee common.Address, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall2(&_Vm.TransactOpts, callee, data) +} + +// ExpectCall2 is a paid mutator transaction binding the contract method 0xbd6af434. +// +// Solidity: function expectCall(address callee, bytes data) returns() +func (_Vm *VmTransactorSession) ExpectCall2(callee common.Address, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall2(&_Vm.TransactOpts, callee, data) +} + +// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff. +// +// Solidity: function expectCall(address callee, bytes data, uint64 count) returns() +func (_Vm *VmTransactor) ExpectCall3(opts *bind.TransactOpts, callee common.Address, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall3", callee, data, count) +} + +// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff. +// +// Solidity: function expectCall(address callee, bytes data, uint64 count) returns() +func (_Vm *VmSession) ExpectCall3(callee common.Address, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall3(&_Vm.TransactOpts, callee, data, count) +} + +// ExpectCall3 is a paid mutator transaction binding the contract method 0xc1adbbff. +// +// Solidity: function expectCall(address callee, bytes data, uint64 count) returns() +func (_Vm *VmTransactorSession) ExpectCall3(callee common.Address, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall3(&_Vm.TransactOpts, callee, data, count) +} + +// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns() +func (_Vm *VmTransactor) ExpectCall4(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCall4", callee, msgValue, data) +} + +// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns() +func (_Vm *VmSession) ExpectCall4(callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall4(&_Vm.TransactOpts, callee, msgValue, data) +} + +// ExpectCall4 is a paid mutator transaction binding the contract method 0xf30c7ba3. +// +// Solidity: function expectCall(address callee, uint256 msgValue, bytes data) returns() +func (_Vm *VmTransactorSession) ExpectCall4(callee common.Address, msgValue *big.Int, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCall4(&_Vm.TransactOpts, callee, msgValue, data) +} + +// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns() +func (_Vm *VmTransactor) ExpectCallMinGas(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCallMinGas", callee, msgValue, minGas, data) +} + +// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns() +func (_Vm *VmSession) ExpectCallMinGas(callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCallMinGas(&_Vm.TransactOpts, callee, msgValue, minGas, data) +} + +// ExpectCallMinGas is a paid mutator transaction binding the contract method 0x08e4e116. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data) returns() +func (_Vm *VmTransactorSession) ExpectCallMinGas(callee common.Address, msgValue *big.Int, minGas uint64, data []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectCallMinGas(&_Vm.TransactOpts, callee, msgValue, minGas, data) +} + +// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns() +func (_Vm *VmTransactor) ExpectCallMinGas0(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectCallMinGas0", callee, msgValue, minGas, data, count) +} + +// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns() +func (_Vm *VmSession) ExpectCallMinGas0(callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCallMinGas0(&_Vm.TransactOpts, callee, msgValue, minGas, data, count) +} + +// ExpectCallMinGas0 is a paid mutator transaction binding the contract method 0xe13a1834. +// +// Solidity: function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes data, uint64 count) returns() +func (_Vm *VmTransactorSession) ExpectCallMinGas0(callee common.Address, msgValue *big.Int, minGas uint64, data []byte, count uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectCallMinGas0(&_Vm.TransactOpts, callee, msgValue, minGas, data, count) +} + +// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d. +// +// Solidity: function expectEmit() returns() +func (_Vm *VmTransactor) ExpectEmit(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectEmit") +} + +// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d. +// +// Solidity: function expectEmit() returns() +func (_Vm *VmSession) ExpectEmit() (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit(&_Vm.TransactOpts) +} + +// ExpectEmit is a paid mutator transaction binding the contract method 0x440ed10d. +// +// Solidity: function expectEmit() returns() +func (_Vm *VmTransactorSession) ExpectEmit() (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit(&_Vm.TransactOpts) +} + +// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns() +func (_Vm *VmTransactor) ExpectEmit0(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectEmit0", checkTopic1, checkTopic2, checkTopic3, checkData) +} + +// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns() +func (_Vm *VmSession) ExpectEmit0(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit0(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData) +} + +// ExpectEmit0 is a paid mutator transaction binding the contract method 0x491cc7c2. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) returns() +func (_Vm *VmTransactorSession) ExpectEmit0(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit0(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData) +} + +// ExpectEmit1 is a paid mutator transaction binding the contract method 0x81bad6f3. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns() +func (_Vm *VmTransactor) ExpectEmit1(opts *bind.TransactOpts, checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectEmit1", checkTopic1, checkTopic2, checkTopic3, checkData, emitter) +} + +// ExpectEmit1 is a paid mutator transaction binding the contract method 0x81bad6f3. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns() +func (_Vm *VmSession) ExpectEmit1(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit1(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter) +} + +// ExpectEmit1 is a paid mutator transaction binding the contract method 0x81bad6f3. +// +// Solidity: function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter) returns() +func (_Vm *VmTransactorSession) ExpectEmit1(checkTopic1 bool, checkTopic2 bool, checkTopic3 bool, checkData bool, emitter common.Address) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit1(&_Vm.TransactOpts, checkTopic1, checkTopic2, checkTopic3, checkData, emitter) +} + +// ExpectEmit2 is a paid mutator transaction binding the contract method 0x86b9620d. +// +// Solidity: function expectEmit(address emitter) returns() +func (_Vm *VmTransactor) ExpectEmit2(opts *bind.TransactOpts, emitter common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectEmit2", emitter) +} + +// ExpectEmit2 is a paid mutator transaction binding the contract method 0x86b9620d. +// +// Solidity: function expectEmit(address emitter) returns() +func (_Vm *VmSession) ExpectEmit2(emitter common.Address) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit2(&_Vm.TransactOpts, emitter) +} + +// ExpectEmit2 is a paid mutator transaction binding the contract method 0x86b9620d. +// +// Solidity: function expectEmit(address emitter) returns() +func (_Vm *VmTransactorSession) ExpectEmit2(emitter common.Address) (*types.Transaction, error) { + return _Vm.Contract.ExpectEmit2(&_Vm.TransactOpts, emitter) +} + +// ExpectRevert is a paid mutator transaction binding the contract method 0xc31eb0e0. +// +// Solidity: function expectRevert(bytes4 revertData) returns() +func (_Vm *VmTransactor) ExpectRevert(opts *bind.TransactOpts, revertData [4]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectRevert", revertData) +} + +// ExpectRevert is a paid mutator transaction binding the contract method 0xc31eb0e0. +// +// Solidity: function expectRevert(bytes4 revertData) returns() +func (_Vm *VmSession) ExpectRevert(revertData [4]byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert(&_Vm.TransactOpts, revertData) +} + +// ExpectRevert is a paid mutator transaction binding the contract method 0xc31eb0e0. +// +// Solidity: function expectRevert(bytes4 revertData) returns() +func (_Vm *VmTransactorSession) ExpectRevert(revertData [4]byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert(&_Vm.TransactOpts, revertData) +} + +// ExpectRevert0 is a paid mutator transaction binding the contract method 0xf28dceb3. +// +// Solidity: function expectRevert(bytes revertData) returns() +func (_Vm *VmTransactor) ExpectRevert0(opts *bind.TransactOpts, revertData []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectRevert0", revertData) +} + +// ExpectRevert0 is a paid mutator transaction binding the contract method 0xf28dceb3. +// +// Solidity: function expectRevert(bytes revertData) returns() +func (_Vm *VmSession) ExpectRevert0(revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert0(&_Vm.TransactOpts, revertData) +} + +// ExpectRevert0 is a paid mutator transaction binding the contract method 0xf28dceb3. +// +// Solidity: function expectRevert(bytes revertData) returns() +func (_Vm *VmTransactorSession) ExpectRevert0(revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert0(&_Vm.TransactOpts, revertData) +} + +// ExpectRevert1 is a paid mutator transaction binding the contract method 0xf4844814. +// +// Solidity: function expectRevert() returns() +func (_Vm *VmTransactor) ExpectRevert1(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectRevert1") +} + +// ExpectRevert1 is a paid mutator transaction binding the contract method 0xf4844814. +// +// Solidity: function expectRevert() returns() +func (_Vm *VmSession) ExpectRevert1() (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert1(&_Vm.TransactOpts) +} + +// ExpectRevert1 is a paid mutator transaction binding the contract method 0xf4844814. +// +// Solidity: function expectRevert() returns() +func (_Vm *VmTransactorSession) ExpectRevert1() (*types.Transaction, error) { + return _Vm.Contract.ExpectRevert1(&_Vm.TransactOpts) +} + +// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688. +// +// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns() +func (_Vm *VmTransactor) ExpectSafeMemory(opts *bind.TransactOpts, min uint64, max uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectSafeMemory", min, max) +} + +// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688. +// +// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns() +func (_Vm *VmSession) ExpectSafeMemory(min uint64, max uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectSafeMemory(&_Vm.TransactOpts, min, max) +} + +// ExpectSafeMemory is a paid mutator transaction binding the contract method 0x6d016688. +// +// Solidity: function expectSafeMemory(uint64 min, uint64 max) returns() +func (_Vm *VmTransactorSession) ExpectSafeMemory(min uint64, max uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectSafeMemory(&_Vm.TransactOpts, min, max) +} + +// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4. +// +// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns() +func (_Vm *VmTransactor) ExpectSafeMemoryCall(opts *bind.TransactOpts, min uint64, max uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "expectSafeMemoryCall", min, max) +} + +// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4. +// +// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns() +func (_Vm *VmSession) ExpectSafeMemoryCall(min uint64, max uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectSafeMemoryCall(&_Vm.TransactOpts, min, max) +} + +// ExpectSafeMemoryCall is a paid mutator transaction binding the contract method 0x05838bf4. +// +// Solidity: function expectSafeMemoryCall(uint64 min, uint64 max) returns() +func (_Vm *VmTransactorSession) ExpectSafeMemoryCall(min uint64, max uint64) (*types.Transaction, error) { + return _Vm.Contract.ExpectSafeMemoryCall(&_Vm.TransactOpts, min, max) +} + +// Fee is a paid mutator transaction binding the contract method 0x39b37ab0. +// +// Solidity: function fee(uint256 newBasefee) returns() +func (_Vm *VmTransactor) Fee(opts *bind.TransactOpts, newBasefee *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "fee", newBasefee) +} + +// Fee is a paid mutator transaction binding the contract method 0x39b37ab0. +// +// Solidity: function fee(uint256 newBasefee) returns() +func (_Vm *VmSession) Fee(newBasefee *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Fee(&_Vm.TransactOpts, newBasefee) +} + +// Fee is a paid mutator transaction binding the contract method 0x39b37ab0. +// +// Solidity: function fee(uint256 newBasefee) returns() +func (_Vm *VmTransactorSession) Fee(newBasefee *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Fee(&_Vm.TransactOpts, newBasefee) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_Vm *VmTransactor) Ffi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "ffi", commandInput) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_Vm *VmSession) Ffi(commandInput []string) (*types.Transaction, error) { + return _Vm.Contract.Ffi(&_Vm.TransactOpts, commandInput) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_Vm *VmTransactorSession) Ffi(commandInput []string) (*types.Transaction, error) { + return _Vm.Contract.Ffi(&_Vm.TransactOpts, commandInput) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_Vm *VmTransactor) GetMappingKeyAndParentOf(opts *bind.TransactOpts, target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "getMappingKeyAndParentOf", target, elementSlot) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_Vm *VmSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _Vm.Contract.GetMappingKeyAndParentOf(&_Vm.TransactOpts, target, elementSlot) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_Vm *VmTransactorSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _Vm.Contract.GetMappingKeyAndParentOf(&_Vm.TransactOpts, target, elementSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_Vm *VmTransactor) GetMappingLength(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "getMappingLength", target, mappingSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_Vm *VmSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _Vm.Contract.GetMappingLength(&_Vm.TransactOpts, target, mappingSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_Vm *VmTransactorSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _Vm.Contract.GetMappingLength(&_Vm.TransactOpts, target, mappingSlot) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_Vm *VmTransactor) GetMappingSlotAt(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "getMappingSlotAt", target, mappingSlot, idx) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_Vm *VmSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _Vm.Contract.GetMappingSlotAt(&_Vm.TransactOpts, target, mappingSlot, idx) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_Vm *VmTransactorSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _Vm.Contract.GetMappingSlotAt(&_Vm.TransactOpts, target, mappingSlot, idx) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_Vm *VmTransactor) GetNonce0(opts *bind.TransactOpts, wallet VmSafeWallet) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "getNonce0", wallet) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_Vm *VmSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) { + return _Vm.Contract.GetNonce0(&_Vm.TransactOpts, wallet) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_Vm *VmTransactorSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) { + return _Vm.Contract.GetNonce0(&_Vm.TransactOpts, wallet) +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_Vm *VmTransactor) GetRecordedLogs(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "getRecordedLogs") +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_Vm *VmSession) GetRecordedLogs() (*types.Transaction, error) { + return _Vm.Contract.GetRecordedLogs(&_Vm.TransactOpts) +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_Vm *VmTransactorSession) GetRecordedLogs() (*types.Transaction, error) { + return _Vm.Contract.GetRecordedLogs(&_Vm.TransactOpts) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_Vm *VmTransactor) IsDir(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "isDir", path) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_Vm *VmSession) IsDir(path string) (*types.Transaction, error) { + return _Vm.Contract.IsDir(&_Vm.TransactOpts, path) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_Vm *VmTransactorSession) IsDir(path string) (*types.Transaction, error) { + return _Vm.Contract.IsDir(&_Vm.TransactOpts, path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_Vm *VmTransactor) IsFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "isFile", path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_Vm *VmSession) IsFile(path string) (*types.Transaction, error) { + return _Vm.Contract.IsFile(&_Vm.TransactOpts, path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_Vm *VmTransactorSession) IsFile(path string) (*types.Transaction, error) { + return _Vm.Contract.IsFile(&_Vm.TransactOpts, path) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_Vm *VmTransactor) Label(opts *bind.TransactOpts, account common.Address, newLabel string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "label", account, newLabel) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_Vm *VmSession) Label(account common.Address, newLabel string) (*types.Transaction, error) { + return _Vm.Contract.Label(&_Vm.TransactOpts, account, newLabel) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_Vm *VmTransactorSession) Label(account common.Address, newLabel string) (*types.Transaction, error) { + return _Vm.Contract.Label(&_Vm.TransactOpts, account, newLabel) +} + +// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7. +// +// Solidity: function loadAllocs(string pathToAllocsJson) returns() +func (_Vm *VmTransactor) LoadAllocs(opts *bind.TransactOpts, pathToAllocsJson string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "loadAllocs", pathToAllocsJson) +} + +// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7. +// +// Solidity: function loadAllocs(string pathToAllocsJson) returns() +func (_Vm *VmSession) LoadAllocs(pathToAllocsJson string) (*types.Transaction, error) { + return _Vm.Contract.LoadAllocs(&_Vm.TransactOpts, pathToAllocsJson) +} + +// LoadAllocs is a paid mutator transaction binding the contract method 0xb3a056d7. +// +// Solidity: function loadAllocs(string pathToAllocsJson) returns() +func (_Vm *VmTransactorSession) LoadAllocs(pathToAllocsJson string) (*types.Transaction, error) { + return _Vm.Contract.LoadAllocs(&_Vm.TransactOpts, pathToAllocsJson) +} + +// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e. +// +// Solidity: function makePersistent(address[] accounts) returns() +func (_Vm *VmTransactor) MakePersistent(opts *bind.TransactOpts, accounts []common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "makePersistent", accounts) +} + +// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e. +// +// Solidity: function makePersistent(address[] accounts) returns() +func (_Vm *VmSession) MakePersistent(accounts []common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent(&_Vm.TransactOpts, accounts) +} + +// MakePersistent is a paid mutator transaction binding the contract method 0x1d9e269e. +// +// Solidity: function makePersistent(address[] accounts) returns() +func (_Vm *VmTransactorSession) MakePersistent(accounts []common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent(&_Vm.TransactOpts, accounts) +} + +// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8. +// +// Solidity: function makePersistent(address account0, address account1) returns() +func (_Vm *VmTransactor) MakePersistent0(opts *bind.TransactOpts, account0 common.Address, account1 common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "makePersistent0", account0, account1) +} + +// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8. +// +// Solidity: function makePersistent(address account0, address account1) returns() +func (_Vm *VmSession) MakePersistent0(account0 common.Address, account1 common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent0(&_Vm.TransactOpts, account0, account1) +} + +// MakePersistent0 is a paid mutator transaction binding the contract method 0x4074e0a8. +// +// Solidity: function makePersistent(address account0, address account1) returns() +func (_Vm *VmTransactorSession) MakePersistent0(account0 common.Address, account1 common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent0(&_Vm.TransactOpts, account0, account1) +} + +// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde. +// +// Solidity: function makePersistent(address account) returns() +func (_Vm *VmTransactor) MakePersistent1(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "makePersistent1", account) +} + +// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde. +// +// Solidity: function makePersistent(address account) returns() +func (_Vm *VmSession) MakePersistent1(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent1(&_Vm.TransactOpts, account) +} + +// MakePersistent1 is a paid mutator transaction binding the contract method 0x57e22dde. +// +// Solidity: function makePersistent(address account) returns() +func (_Vm *VmTransactorSession) MakePersistent1(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent1(&_Vm.TransactOpts, account) +} + +// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75. +// +// Solidity: function makePersistent(address account0, address account1, address account2) returns() +func (_Vm *VmTransactor) MakePersistent2(opts *bind.TransactOpts, account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "makePersistent2", account0, account1, account2) +} + +// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75. +// +// Solidity: function makePersistent(address account0, address account1, address account2) returns() +func (_Vm *VmSession) MakePersistent2(account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent2(&_Vm.TransactOpts, account0, account1, account2) +} + +// MakePersistent2 is a paid mutator transaction binding the contract method 0xefb77a75. +// +// Solidity: function makePersistent(address account0, address account1, address account2) returns() +func (_Vm *VmTransactorSession) MakePersistent2(account0 common.Address, account1 common.Address, account2 common.Address) (*types.Transaction, error) { + return _Vm.Contract.MakePersistent2(&_Vm.TransactOpts, account0, account1, account2) +} + +// MockCall is a paid mutator transaction binding the contract method 0x81409b91. +// +// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns() +func (_Vm *VmTransactor) MockCall(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "mockCall", callee, msgValue, data, returnData) +} + +// MockCall is a paid mutator transaction binding the contract method 0x81409b91. +// +// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns() +func (_Vm *VmSession) MockCall(callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCall(&_Vm.TransactOpts, callee, msgValue, data, returnData) +} + +// MockCall is a paid mutator transaction binding the contract method 0x81409b91. +// +// Solidity: function mockCall(address callee, uint256 msgValue, bytes data, bytes returnData) returns() +func (_Vm *VmTransactorSession) MockCall(callee common.Address, msgValue *big.Int, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCall(&_Vm.TransactOpts, callee, msgValue, data, returnData) +} + +// MockCall0 is a paid mutator transaction binding the contract method 0xb96213e4. +// +// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns() +func (_Vm *VmTransactor) MockCall0(opts *bind.TransactOpts, callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "mockCall0", callee, data, returnData) +} + +// MockCall0 is a paid mutator transaction binding the contract method 0xb96213e4. +// +// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns() +func (_Vm *VmSession) MockCall0(callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCall0(&_Vm.TransactOpts, callee, data, returnData) +} + +// MockCall0 is a paid mutator transaction binding the contract method 0xb96213e4. +// +// Solidity: function mockCall(address callee, bytes data, bytes returnData) returns() +func (_Vm *VmTransactorSession) MockCall0(callee common.Address, data []byte, returnData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCall0(&_Vm.TransactOpts, callee, data, returnData) +} + +// MockCallRevert is a paid mutator transaction binding the contract method 0xd23cd037. +// +// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns() +func (_Vm *VmTransactor) MockCallRevert(opts *bind.TransactOpts, callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "mockCallRevert", callee, msgValue, data, revertData) +} + +// MockCallRevert is a paid mutator transaction binding the contract method 0xd23cd037. +// +// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns() +func (_Vm *VmSession) MockCallRevert(callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCallRevert(&_Vm.TransactOpts, callee, msgValue, data, revertData) +} + +// MockCallRevert is a paid mutator transaction binding the contract method 0xd23cd037. +// +// Solidity: function mockCallRevert(address callee, uint256 msgValue, bytes data, bytes revertData) returns() +func (_Vm *VmTransactorSession) MockCallRevert(callee common.Address, msgValue *big.Int, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCallRevert(&_Vm.TransactOpts, callee, msgValue, data, revertData) +} + +// MockCallRevert0 is a paid mutator transaction binding the contract method 0xdbaad147. +// +// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns() +func (_Vm *VmTransactor) MockCallRevert0(opts *bind.TransactOpts, callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "mockCallRevert0", callee, data, revertData) +} + +// MockCallRevert0 is a paid mutator transaction binding the contract method 0xdbaad147. +// +// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns() +func (_Vm *VmSession) MockCallRevert0(callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCallRevert0(&_Vm.TransactOpts, callee, data, revertData) +} + +// MockCallRevert0 is a paid mutator transaction binding the contract method 0xdbaad147. +// +// Solidity: function mockCallRevert(address callee, bytes data, bytes revertData) returns() +func (_Vm *VmTransactorSession) MockCallRevert0(callee common.Address, data []byte, revertData []byte) (*types.Transaction, error) { + return _Vm.Contract.MockCallRevert0(&_Vm.TransactOpts, callee, data, revertData) +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_Vm *VmTransactor) PauseGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "pauseGasMetering") +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_Vm *VmSession) PauseGasMetering() (*types.Transaction, error) { + return _Vm.Contract.PauseGasMetering(&_Vm.TransactOpts) +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_Vm *VmTransactorSession) PauseGasMetering() (*types.Transaction, error) { + return _Vm.Contract.PauseGasMetering(&_Vm.TransactOpts) +} + +// Prank is a paid mutator transaction binding the contract method 0x47e50cce. +// +// Solidity: function prank(address msgSender, address txOrigin) returns() +func (_Vm *VmTransactor) Prank(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "prank", msgSender, txOrigin) +} + +// Prank is a paid mutator transaction binding the contract method 0x47e50cce. +// +// Solidity: function prank(address msgSender, address txOrigin) returns() +func (_Vm *VmSession) Prank(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.Contract.Prank(&_Vm.TransactOpts, msgSender, txOrigin) +} + +// Prank is a paid mutator transaction binding the contract method 0x47e50cce. +// +// Solidity: function prank(address msgSender, address txOrigin) returns() +func (_Vm *VmTransactorSession) Prank(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.Contract.Prank(&_Vm.TransactOpts, msgSender, txOrigin) +} + +// Prank0 is a paid mutator transaction binding the contract method 0xca669fa7. +// +// Solidity: function prank(address msgSender) returns() +func (_Vm *VmTransactor) Prank0(opts *bind.TransactOpts, msgSender common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "prank0", msgSender) +} + +// Prank0 is a paid mutator transaction binding the contract method 0xca669fa7. +// +// Solidity: function prank(address msgSender) returns() +func (_Vm *VmSession) Prank0(msgSender common.Address) (*types.Transaction, error) { + return _Vm.Contract.Prank0(&_Vm.TransactOpts, msgSender) +} + +// Prank0 is a paid mutator transaction binding the contract method 0xca669fa7. +// +// Solidity: function prank(address msgSender) returns() +func (_Vm *VmTransactorSession) Prank0(msgSender common.Address) (*types.Transaction, error) { + return _Vm.Contract.Prank0(&_Vm.TransactOpts, msgSender) +} + +// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549. +// +// Solidity: function prevrandao(bytes32 newPrevrandao) returns() +func (_Vm *VmTransactor) Prevrandao(opts *bind.TransactOpts, newPrevrandao [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "prevrandao", newPrevrandao) +} + +// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549. +// +// Solidity: function prevrandao(bytes32 newPrevrandao) returns() +func (_Vm *VmSession) Prevrandao(newPrevrandao [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Prevrandao(&_Vm.TransactOpts, newPrevrandao) +} + +// Prevrandao is a paid mutator transaction binding the contract method 0x3b925549. +// +// Solidity: function prevrandao(bytes32 newPrevrandao) returns() +func (_Vm *VmTransactorSession) Prevrandao(newPrevrandao [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Prevrandao(&_Vm.TransactOpts, newPrevrandao) +} + +// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4. +// +// Solidity: function prevrandao(uint256 newPrevrandao) returns() +func (_Vm *VmTransactor) Prevrandao0(opts *bind.TransactOpts, newPrevrandao *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "prevrandao0", newPrevrandao) +} + +// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4. +// +// Solidity: function prevrandao(uint256 newPrevrandao) returns() +func (_Vm *VmSession) Prevrandao0(newPrevrandao *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Prevrandao0(&_Vm.TransactOpts, newPrevrandao) +} + +// Prevrandao0 is a paid mutator transaction binding the contract method 0x9cb1c0d4. +// +// Solidity: function prevrandao(uint256 newPrevrandao) returns() +func (_Vm *VmTransactorSession) Prevrandao0(newPrevrandao *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Prevrandao0(&_Vm.TransactOpts, newPrevrandao) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_Vm *VmTransactor) Prompt(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "prompt", promptText) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_Vm *VmSession) Prompt(promptText string) (*types.Transaction, error) { + return _Vm.Contract.Prompt(&_Vm.TransactOpts, promptText) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_Vm *VmTransactorSession) Prompt(promptText string) (*types.Transaction, error) { + return _Vm.Contract.Prompt(&_Vm.TransactOpts, promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_Vm *VmTransactor) PromptAddress(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "promptAddress", promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_Vm *VmSession) PromptAddress(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptAddress(&_Vm.TransactOpts, promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_Vm *VmTransactorSession) PromptAddress(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptAddress(&_Vm.TransactOpts, promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_Vm *VmTransactor) PromptSecret(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "promptSecret", promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_Vm *VmSession) PromptSecret(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptSecret(&_Vm.TransactOpts, promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_Vm *VmTransactorSession) PromptSecret(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptSecret(&_Vm.TransactOpts, promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_Vm *VmTransactor) PromptSecretUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "promptSecretUint", promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_Vm *VmSession) PromptSecretUint(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptSecretUint(&_Vm.TransactOpts, promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_Vm *VmTransactorSession) PromptSecretUint(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptSecretUint(&_Vm.TransactOpts, promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_Vm *VmTransactor) PromptUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "promptUint", promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_Vm *VmSession) PromptUint(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptUint(&_Vm.TransactOpts, promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_Vm *VmTransactorSession) PromptUint(promptText string) (*types.Transaction, error) { + return _Vm.Contract.PromptUint(&_Vm.TransactOpts, promptText) +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_Vm *VmTransactor) RandomAddress(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "randomAddress") +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_Vm *VmSession) RandomAddress() (*types.Transaction, error) { + return _Vm.Contract.RandomAddress(&_Vm.TransactOpts) +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_Vm *VmTransactorSession) RandomAddress() (*types.Transaction, error) { + return _Vm.Contract.RandomAddress(&_Vm.TransactOpts) +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_Vm *VmTransactor) RandomUint(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "randomUint") +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_Vm *VmSession) RandomUint() (*types.Transaction, error) { + return _Vm.Contract.RandomUint(&_Vm.TransactOpts) +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_Vm *VmTransactorSession) RandomUint() (*types.Transaction, error) { + return _Vm.Contract.RandomUint(&_Vm.TransactOpts) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_Vm *VmTransactor) RandomUint0(opts *bind.TransactOpts, min *big.Int, max *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "randomUint0", min, max) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_Vm *VmSession) RandomUint0(min *big.Int, max *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RandomUint0(&_Vm.TransactOpts, min, max) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_Vm *VmTransactorSession) RandomUint0(min *big.Int, max *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RandomUint0(&_Vm.TransactOpts, min, max) +} + +// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9. +// +// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin) +func (_Vm *VmTransactor) ReadCallers(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "readCallers") +} + +// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9. +// +// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin) +func (_Vm *VmSession) ReadCallers() (*types.Transaction, error) { + return _Vm.Contract.ReadCallers(&_Vm.TransactOpts) +} + +// ReadCallers is a paid mutator transaction binding the contract method 0x4ad0bac9. +// +// Solidity: function readCallers() returns(uint8 callerMode, address msgSender, address txOrigin) +func (_Vm *VmTransactorSession) ReadCallers() (*types.Transaction, error) { + return _Vm.Contract.ReadCallers(&_Vm.TransactOpts) +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_Vm *VmTransactor) Record(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "record") +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_Vm *VmSession) Record() (*types.Transaction, error) { + return _Vm.Contract.Record(&_Vm.TransactOpts) +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_Vm *VmTransactorSession) Record() (*types.Transaction, error) { + return _Vm.Contract.Record(&_Vm.TransactOpts) +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_Vm *VmTransactor) RecordLogs(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "recordLogs") +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_Vm *VmSession) RecordLogs() (*types.Transaction, error) { + return _Vm.Contract.RecordLogs(&_Vm.TransactOpts) +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_Vm *VmTransactorSession) RecordLogs() (*types.Transaction, error) { + return _Vm.Contract.RecordLogs(&_Vm.TransactOpts) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_Vm *VmTransactor) RememberKey(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rememberKey", privateKey) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_Vm *VmSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RememberKey(&_Vm.TransactOpts, privateKey) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_Vm *VmTransactorSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RememberKey(&_Vm.TransactOpts, privateKey) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_Vm *VmTransactor) RemoveDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "removeDir", path, recursive) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_Vm *VmSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) { + return _Vm.Contract.RemoveDir(&_Vm.TransactOpts, path, recursive) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_Vm *VmTransactorSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) { + return _Vm.Contract.RemoveDir(&_Vm.TransactOpts, path, recursive) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_Vm *VmTransactor) RemoveFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "removeFile", path) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_Vm *VmSession) RemoveFile(path string) (*types.Transaction, error) { + return _Vm.Contract.RemoveFile(&_Vm.TransactOpts, path) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_Vm *VmTransactorSession) RemoveFile(path string) (*types.Transaction, error) { + return _Vm.Contract.RemoveFile(&_Vm.TransactOpts, path) +} + +// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d. +// +// Solidity: function resetNonce(address account) returns() +func (_Vm *VmTransactor) ResetNonce(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "resetNonce", account) +} + +// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d. +// +// Solidity: function resetNonce(address account) returns() +func (_Vm *VmSession) ResetNonce(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.ResetNonce(&_Vm.TransactOpts, account) +} + +// ResetNonce is a paid mutator transaction binding the contract method 0x1c72346d. +// +// Solidity: function resetNonce(address account) returns() +func (_Vm *VmTransactorSession) ResetNonce(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.ResetNonce(&_Vm.TransactOpts, account) +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_Vm *VmTransactor) ResumeGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "resumeGasMetering") +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_Vm *VmSession) ResumeGasMetering() (*types.Transaction, error) { + return _Vm.Contract.ResumeGasMetering(&_Vm.TransactOpts) +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_Vm *VmTransactorSession) ResumeGasMetering() (*types.Transaction, error) { + return _Vm.Contract.ResumeGasMetering(&_Vm.TransactOpts) +} + +// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4. +// +// Solidity: function revertTo(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactor) RevertTo(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "revertTo", snapshotId) +} + +// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4. +// +// Solidity: function revertTo(uint256 snapshotId) returns(bool success) +func (_Vm *VmSession) RevertTo(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RevertTo(&_Vm.TransactOpts, snapshotId) +} + +// RevertTo is a paid mutator transaction binding the contract method 0x44d7f0a4. +// +// Solidity: function revertTo(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactorSession) RevertTo(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RevertTo(&_Vm.TransactOpts, snapshotId) +} + +// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9. +// +// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactor) RevertToAndDelete(opts *bind.TransactOpts, snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "revertToAndDelete", snapshotId) +} + +// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9. +// +// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success) +func (_Vm *VmSession) RevertToAndDelete(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RevertToAndDelete(&_Vm.TransactOpts, snapshotId) +} + +// RevertToAndDelete is a paid mutator transaction binding the contract method 0x03e0aca9. +// +// Solidity: function revertToAndDelete(uint256 snapshotId) returns(bool success) +func (_Vm *VmTransactorSession) RevertToAndDelete(snapshotId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RevertToAndDelete(&_Vm.TransactOpts, snapshotId) +} + +// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6. +// +// Solidity: function revokePersistent(address[] accounts) returns() +func (_Vm *VmTransactor) RevokePersistent(opts *bind.TransactOpts, accounts []common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "revokePersistent", accounts) +} + +// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6. +// +// Solidity: function revokePersistent(address[] accounts) returns() +func (_Vm *VmSession) RevokePersistent(accounts []common.Address) (*types.Transaction, error) { + return _Vm.Contract.RevokePersistent(&_Vm.TransactOpts, accounts) +} + +// RevokePersistent is a paid mutator transaction binding the contract method 0x3ce969e6. +// +// Solidity: function revokePersistent(address[] accounts) returns() +func (_Vm *VmTransactorSession) RevokePersistent(accounts []common.Address) (*types.Transaction, error) { + return _Vm.Contract.RevokePersistent(&_Vm.TransactOpts, accounts) +} + +// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222. +// +// Solidity: function revokePersistent(address account) returns() +func (_Vm *VmTransactor) RevokePersistent0(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "revokePersistent0", account) +} + +// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222. +// +// Solidity: function revokePersistent(address account) returns() +func (_Vm *VmSession) RevokePersistent0(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.RevokePersistent0(&_Vm.TransactOpts, account) +} + +// RevokePersistent0 is a paid mutator transaction binding the contract method 0x997a0222. +// +// Solidity: function revokePersistent(address account) returns() +func (_Vm *VmTransactorSession) RevokePersistent0(account common.Address) (*types.Transaction, error) { + return _Vm.Contract.RevokePersistent0(&_Vm.TransactOpts, account) +} + +// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30. +// +// Solidity: function roll(uint256 newHeight) returns() +func (_Vm *VmTransactor) Roll(opts *bind.TransactOpts, newHeight *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "roll", newHeight) +} + +// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30. +// +// Solidity: function roll(uint256 newHeight) returns() +func (_Vm *VmSession) Roll(newHeight *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Roll(&_Vm.TransactOpts, newHeight) +} + +// Roll is a paid mutator transaction binding the contract method 0x1f7b4f30. +// +// Solidity: function roll(uint256 newHeight) returns() +func (_Vm *VmTransactorSession) Roll(newHeight *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Roll(&_Vm.TransactOpts, newHeight) +} + +// RollFork is a paid mutator transaction binding the contract method 0x0f29772b. +// +// Solidity: function rollFork(bytes32 txHash) returns() +func (_Vm *VmTransactor) RollFork(opts *bind.TransactOpts, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rollFork", txHash) +} + +// RollFork is a paid mutator transaction binding the contract method 0x0f29772b. +// +// Solidity: function rollFork(bytes32 txHash) returns() +func (_Vm *VmSession) RollFork(txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.RollFork(&_Vm.TransactOpts, txHash) +} + +// RollFork is a paid mutator transaction binding the contract method 0x0f29772b. +// +// Solidity: function rollFork(bytes32 txHash) returns() +func (_Vm *VmTransactorSession) RollFork(txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.RollFork(&_Vm.TransactOpts, txHash) +} + +// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4. +// +// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns() +func (_Vm *VmTransactor) RollFork0(opts *bind.TransactOpts, forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rollFork0", forkId, blockNumber) +} + +// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4. +// +// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns() +func (_Vm *VmSession) RollFork0(forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RollFork0(&_Vm.TransactOpts, forkId, blockNumber) +} + +// RollFork0 is a paid mutator transaction binding the contract method 0xd74c83a4. +// +// Solidity: function rollFork(uint256 forkId, uint256 blockNumber) returns() +func (_Vm *VmTransactorSession) RollFork0(forkId *big.Int, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RollFork0(&_Vm.TransactOpts, forkId, blockNumber) +} + +// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1. +// +// Solidity: function rollFork(uint256 blockNumber) returns() +func (_Vm *VmTransactor) RollFork1(opts *bind.TransactOpts, blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rollFork1", blockNumber) +} + +// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1. +// +// Solidity: function rollFork(uint256 blockNumber) returns() +func (_Vm *VmSession) RollFork1(blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RollFork1(&_Vm.TransactOpts, blockNumber) +} + +// RollFork1 is a paid mutator transaction binding the contract method 0xd9bbf3a1. +// +// Solidity: function rollFork(uint256 blockNumber) returns() +func (_Vm *VmTransactorSession) RollFork1(blockNumber *big.Int) (*types.Transaction, error) { + return _Vm.Contract.RollFork1(&_Vm.TransactOpts, blockNumber) +} + +// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b. +// +// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmTransactor) RollFork2(opts *bind.TransactOpts, forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rollFork2", forkId, txHash) +} + +// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b. +// +// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmSession) RollFork2(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.RollFork2(&_Vm.TransactOpts, forkId, txHash) +} + +// RollFork2 is a paid mutator transaction binding the contract method 0xf2830f7b. +// +// Solidity: function rollFork(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmTransactorSession) RollFork2(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.RollFork2(&_Vm.TransactOpts, forkId, txHash) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_Vm *VmTransactor) Rpc(opts *bind.TransactOpts, method string, params string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "rpc", method, params) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_Vm *VmSession) Rpc(method string, params string) (*types.Transaction, error) { + return _Vm.Contract.Rpc(&_Vm.TransactOpts, method, params) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_Vm *VmTransactorSession) Rpc(method string, params string) (*types.Transaction, error) { + return _Vm.Contract.Rpc(&_Vm.TransactOpts, method, params) +} + +// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827. +// +// Solidity: function selectFork(uint256 forkId) returns() +func (_Vm *VmTransactor) SelectFork(opts *bind.TransactOpts, forkId *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "selectFork", forkId) +} + +// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827. +// +// Solidity: function selectFork(uint256 forkId) returns() +func (_Vm *VmSession) SelectFork(forkId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SelectFork(&_Vm.TransactOpts, forkId) +} + +// SelectFork is a paid mutator transaction binding the contract method 0x9ebf6827. +// +// Solidity: function selectFork(uint256 forkId) returns() +func (_Vm *VmTransactorSession) SelectFork(forkId *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SelectFork(&_Vm.TransactOpts, forkId) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_Vm *VmTransactor) SerializeAddress(opts *bind.TransactOpts, objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeAddress", objectKey, valueKey, values) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_Vm *VmSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _Vm.Contract.SerializeAddress(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _Vm.Contract.SerializeAddress(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_Vm *VmTransactor) SerializeAddress0(opts *bind.TransactOpts, objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeAddress0", objectKey, valueKey, value) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_Vm *VmSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _Vm.Contract.SerializeAddress0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_Vm *VmTransactorSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _Vm.Contract.SerializeAddress0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_Vm *VmTransactor) SerializeBool(opts *bind.TransactOpts, objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBool", objectKey, valueKey, values) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_Vm *VmSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _Vm.Contract.SerializeBool(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _Vm.Contract.SerializeBool(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_Vm *VmTransactor) SerializeBool0(opts *bind.TransactOpts, objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBool0", objectKey, valueKey, value) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_Vm *VmSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _Vm.Contract.SerializeBool0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_Vm *VmTransactorSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _Vm.Contract.SerializeBool0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_Vm *VmTransactor) SerializeBytes(opts *bind.TransactOpts, objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBytes", objectKey, valueKey, values) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_Vm *VmSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_Vm *VmTransactor) SerializeBytes0(opts *bind.TransactOpts, objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBytes0", objectKey, valueKey, value) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_Vm *VmSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_Vm *VmTransactorSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_Vm *VmTransactor) SerializeBytes32(opts *bind.TransactOpts, objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBytes32", objectKey, valueKey, values) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_Vm *VmSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes32(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes32(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_Vm *VmTransactor) SerializeBytes320(opts *bind.TransactOpts, objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeBytes320", objectKey, valueKey, value) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_Vm *VmSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes320(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_Vm *VmTransactorSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _Vm.Contract.SerializeBytes320(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_Vm *VmTransactor) SerializeInt(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeInt", objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_Vm *VmSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeInt(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_Vm *VmTransactorSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeInt(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_Vm *VmTransactor) SerializeInt0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeInt0", objectKey, valueKey, values) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_Vm *VmSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeInt0(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeInt0(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_Vm *VmTransactor) SerializeJson(opts *bind.TransactOpts, objectKey string, value string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeJson", objectKey, value) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_Vm *VmSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) { + return _Vm.Contract.SerializeJson(&_Vm.TransactOpts, objectKey, value) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_Vm *VmTransactorSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) { + return _Vm.Contract.SerializeJson(&_Vm.TransactOpts, objectKey, value) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_Vm *VmTransactor) SerializeString(opts *bind.TransactOpts, objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeString", objectKey, valueKey, values) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_Vm *VmSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _Vm.Contract.SerializeString(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _Vm.Contract.SerializeString(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_Vm *VmTransactor) SerializeString0(opts *bind.TransactOpts, objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeString0", objectKey, valueKey, value) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_Vm *VmSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _Vm.Contract.SerializeString0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_Vm *VmTransactorSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _Vm.Contract.SerializeString0(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmTransactor) SerializeUint(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeUint", objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUint(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmTransactorSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUint(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_Vm *VmTransactor) SerializeUint0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeUint0", objectKey, valueKey, values) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_Vm *VmSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUint0(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_Vm *VmTransactorSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUint0(&_Vm.TransactOpts, objectKey, valueKey, values) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmTransactor) SerializeUintToHex(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "serializeUintToHex", objectKey, valueKey, value) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUintToHex(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_Vm *VmTransactorSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _Vm.Contract.SerializeUintToHex(&_Vm.TransactOpts, objectKey, valueKey, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_Vm *VmTransactor) SetEnv(opts *bind.TransactOpts, name string, value string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "setEnv", name, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_Vm *VmSession) SetEnv(name string, value string) (*types.Transaction, error) { + return _Vm.Contract.SetEnv(&_Vm.TransactOpts, name, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_Vm *VmTransactorSession) SetEnv(name string, value string) (*types.Transaction, error) { + return _Vm.Contract.SetEnv(&_Vm.TransactOpts, name, value) +} + +// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57. +// +// Solidity: function setNonce(address account, uint64 newNonce) returns() +func (_Vm *VmTransactor) SetNonce(opts *bind.TransactOpts, account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "setNonce", account, newNonce) +} + +// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57. +// +// Solidity: function setNonce(address account, uint64 newNonce) returns() +func (_Vm *VmSession) SetNonce(account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.Contract.SetNonce(&_Vm.TransactOpts, account, newNonce) +} + +// SetNonce is a paid mutator transaction binding the contract method 0xf8e18b57. +// +// Solidity: function setNonce(address account, uint64 newNonce) returns() +func (_Vm *VmTransactorSession) SetNonce(account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.Contract.SetNonce(&_Vm.TransactOpts, account, newNonce) +} + +// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c. +// +// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns() +func (_Vm *VmTransactor) SetNonceUnsafe(opts *bind.TransactOpts, account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "setNonceUnsafe", account, newNonce) +} + +// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c. +// +// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns() +func (_Vm *VmSession) SetNonceUnsafe(account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.Contract.SetNonceUnsafe(&_Vm.TransactOpts, account, newNonce) +} + +// SetNonceUnsafe is a paid mutator transaction binding the contract method 0x9b67b21c. +// +// Solidity: function setNonceUnsafe(address account, uint64 newNonce) returns() +func (_Vm *VmTransactorSession) SetNonceUnsafe(account common.Address, newNonce uint64) (*types.Transaction, error) { + return _Vm.Contract.SetNonceUnsafe(&_Vm.TransactOpts, account, newNonce) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmTransactor) Sign1(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "sign1", wallet, digest) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Sign1(&_Vm.TransactOpts, wallet, digest) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_Vm *VmTransactorSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Sign1(&_Vm.TransactOpts, wallet, digest) +} + +// Skip is a paid mutator transaction binding the contract method 0xdd82d13e. +// +// Solidity: function skip(bool skipTest) returns() +func (_Vm *VmTransactor) Skip(opts *bind.TransactOpts, skipTest bool) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "skip", skipTest) +} + +// Skip is a paid mutator transaction binding the contract method 0xdd82d13e. +// +// Solidity: function skip(bool skipTest) returns() +func (_Vm *VmSession) Skip(skipTest bool) (*types.Transaction, error) { + return _Vm.Contract.Skip(&_Vm.TransactOpts, skipTest) +} + +// Skip is a paid mutator transaction binding the contract method 0xdd82d13e. +// +// Solidity: function skip(bool skipTest) returns() +func (_Vm *VmTransactorSession) Skip(skipTest bool) (*types.Transaction, error) { + return _Vm.Contract.Skip(&_Vm.TransactOpts, skipTest) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_Vm *VmTransactor) Sleep(opts *bind.TransactOpts, duration *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "sleep", duration) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_Vm *VmSession) Sleep(duration *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Sleep(&_Vm.TransactOpts, duration) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_Vm *VmTransactorSession) Sleep(duration *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Sleep(&_Vm.TransactOpts, duration) +} + +// Snapshot is a paid mutator transaction binding the contract method 0x9711715a. +// +// Solidity: function snapshot() returns(uint256 snapshotId) +func (_Vm *VmTransactor) Snapshot(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "snapshot") +} + +// Snapshot is a paid mutator transaction binding the contract method 0x9711715a. +// +// Solidity: function snapshot() returns(uint256 snapshotId) +func (_Vm *VmSession) Snapshot() (*types.Transaction, error) { + return _Vm.Contract.Snapshot(&_Vm.TransactOpts) +} + +// Snapshot is a paid mutator transaction binding the contract method 0x9711715a. +// +// Solidity: function snapshot() returns(uint256 snapshotId) +func (_Vm *VmTransactorSession) Snapshot() (*types.Transaction, error) { + return _Vm.Contract.Snapshot(&_Vm.TransactOpts) +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_Vm *VmTransactor) StartBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startBroadcast") +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_Vm *VmSession) StartBroadcast() (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast(&_Vm.TransactOpts) +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_Vm *VmTransactorSession) StartBroadcast() (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast(&_Vm.TransactOpts) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_Vm *VmTransactor) StartBroadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startBroadcast0", signer) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_Vm *VmSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast0(&_Vm.TransactOpts, signer) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_Vm *VmTransactorSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast0(&_Vm.TransactOpts, signer) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_Vm *VmTransactor) StartBroadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startBroadcast1", privateKey) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_Vm *VmSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast1(&_Vm.TransactOpts, privateKey) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_Vm *VmTransactorSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _Vm.Contract.StartBroadcast1(&_Vm.TransactOpts, privateKey) +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_Vm *VmTransactor) StartMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startMappingRecording") +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_Vm *VmSession) StartMappingRecording() (*types.Transaction, error) { + return _Vm.Contract.StartMappingRecording(&_Vm.TransactOpts) +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_Vm *VmTransactorSession) StartMappingRecording() (*types.Transaction, error) { + return _Vm.Contract.StartMappingRecording(&_Vm.TransactOpts) +} + +// StartPrank is a paid mutator transaction binding the contract method 0x06447d56. +// +// Solidity: function startPrank(address msgSender) returns() +func (_Vm *VmTransactor) StartPrank(opts *bind.TransactOpts, msgSender common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startPrank", msgSender) +} + +// StartPrank is a paid mutator transaction binding the contract method 0x06447d56. +// +// Solidity: function startPrank(address msgSender) returns() +func (_Vm *VmSession) StartPrank(msgSender common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartPrank(&_Vm.TransactOpts, msgSender) +} + +// StartPrank is a paid mutator transaction binding the contract method 0x06447d56. +// +// Solidity: function startPrank(address msgSender) returns() +func (_Vm *VmTransactorSession) StartPrank(msgSender common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartPrank(&_Vm.TransactOpts, msgSender) +} + +// StartPrank0 is a paid mutator transaction binding the contract method 0x45b56078. +// +// Solidity: function startPrank(address msgSender, address txOrigin) returns() +func (_Vm *VmTransactor) StartPrank0(opts *bind.TransactOpts, msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startPrank0", msgSender, txOrigin) +} + +// StartPrank0 is a paid mutator transaction binding the contract method 0x45b56078. +// +// Solidity: function startPrank(address msgSender, address txOrigin) returns() +func (_Vm *VmSession) StartPrank0(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartPrank0(&_Vm.TransactOpts, msgSender, txOrigin) +} + +// StartPrank0 is a paid mutator transaction binding the contract method 0x45b56078. +// +// Solidity: function startPrank(address msgSender, address txOrigin) returns() +func (_Vm *VmTransactorSession) StartPrank0(msgSender common.Address, txOrigin common.Address) (*types.Transaction, error) { + return _Vm.Contract.StartPrank0(&_Vm.TransactOpts, msgSender, txOrigin) +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_Vm *VmTransactor) StartStateDiffRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "startStateDiffRecording") +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_Vm *VmSession) StartStateDiffRecording() (*types.Transaction, error) { + return _Vm.Contract.StartStateDiffRecording(&_Vm.TransactOpts) +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_Vm *VmTransactorSession) StartStateDiffRecording() (*types.Transaction, error) { + return _Vm.Contract.StartStateDiffRecording(&_Vm.TransactOpts) +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_Vm *VmTransactor) StopAndReturnStateDiff(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "stopAndReturnStateDiff") +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_Vm *VmSession) StopAndReturnStateDiff() (*types.Transaction, error) { + return _Vm.Contract.StopAndReturnStateDiff(&_Vm.TransactOpts) +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_Vm *VmTransactorSession) StopAndReturnStateDiff() (*types.Transaction, error) { + return _Vm.Contract.StopAndReturnStateDiff(&_Vm.TransactOpts) +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_Vm *VmTransactor) StopBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "stopBroadcast") +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_Vm *VmSession) StopBroadcast() (*types.Transaction, error) { + return _Vm.Contract.StopBroadcast(&_Vm.TransactOpts) +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_Vm *VmTransactorSession) StopBroadcast() (*types.Transaction, error) { + return _Vm.Contract.StopBroadcast(&_Vm.TransactOpts) +} + +// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b. +// +// Solidity: function stopExpectSafeMemory() returns() +func (_Vm *VmTransactor) StopExpectSafeMemory(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "stopExpectSafeMemory") +} + +// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b. +// +// Solidity: function stopExpectSafeMemory() returns() +func (_Vm *VmSession) StopExpectSafeMemory() (*types.Transaction, error) { + return _Vm.Contract.StopExpectSafeMemory(&_Vm.TransactOpts) +} + +// StopExpectSafeMemory is a paid mutator transaction binding the contract method 0x0956441b. +// +// Solidity: function stopExpectSafeMemory() returns() +func (_Vm *VmTransactorSession) StopExpectSafeMemory() (*types.Transaction, error) { + return _Vm.Contract.StopExpectSafeMemory(&_Vm.TransactOpts) +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_Vm *VmTransactor) StopMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "stopMappingRecording") +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_Vm *VmSession) StopMappingRecording() (*types.Transaction, error) { + return _Vm.Contract.StopMappingRecording(&_Vm.TransactOpts) +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_Vm *VmTransactorSession) StopMappingRecording() (*types.Transaction, error) { + return _Vm.Contract.StopMappingRecording(&_Vm.TransactOpts) +} + +// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b. +// +// Solidity: function stopPrank() returns() +func (_Vm *VmTransactor) StopPrank(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "stopPrank") +} + +// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b. +// +// Solidity: function stopPrank() returns() +func (_Vm *VmSession) StopPrank() (*types.Transaction, error) { + return _Vm.Contract.StopPrank(&_Vm.TransactOpts) +} + +// StopPrank is a paid mutator transaction binding the contract method 0x90c5013b. +// +// Solidity: function stopPrank() returns() +func (_Vm *VmTransactorSession) StopPrank() (*types.Transaction, error) { + return _Vm.Contract.StopPrank(&_Vm.TransactOpts) +} + +// Store is a paid mutator transaction binding the contract method 0x70ca10bb. +// +// Solidity: function store(address target, bytes32 slot, bytes32 value) returns() +func (_Vm *VmTransactor) Store(opts *bind.TransactOpts, target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "store", target, slot, value) +} + +// Store is a paid mutator transaction binding the contract method 0x70ca10bb. +// +// Solidity: function store(address target, bytes32 slot, bytes32 value) returns() +func (_Vm *VmSession) Store(target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Store(&_Vm.TransactOpts, target, slot, value) +} + +// Store is a paid mutator transaction binding the contract method 0x70ca10bb. +// +// Solidity: function store(address target, bytes32 slot, bytes32 value) returns() +func (_Vm *VmTransactorSession) Store(target common.Address, slot [32]byte, value [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Store(&_Vm.TransactOpts, target, slot, value) +} + +// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b. +// +// Solidity: function transact(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmTransactor) Transact(opts *bind.TransactOpts, forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "transact", forkId, txHash) +} + +// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b. +// +// Solidity: function transact(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmSession) Transact(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Transact(&_Vm.TransactOpts, forkId, txHash) +} + +// Transact is a paid mutator transaction binding the contract method 0x4d8abc4b. +// +// Solidity: function transact(uint256 forkId, bytes32 txHash) returns() +func (_Vm *VmTransactorSession) Transact(forkId *big.Int, txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Transact(&_Vm.TransactOpts, forkId, txHash) +} + +// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1. +// +// Solidity: function transact(bytes32 txHash) returns() +func (_Vm *VmTransactor) Transact0(opts *bind.TransactOpts, txHash [32]byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "transact0", txHash) +} + +// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1. +// +// Solidity: function transact(bytes32 txHash) returns() +func (_Vm *VmSession) Transact0(txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Transact0(&_Vm.TransactOpts, txHash) +} + +// Transact0 is a paid mutator transaction binding the contract method 0xbe646da1. +// +// Solidity: function transact(bytes32 txHash) returns() +func (_Vm *VmTransactorSession) Transact0(txHash [32]byte) (*types.Transaction, error) { + return _Vm.Contract.Transact0(&_Vm.TransactOpts, txHash) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_Vm *VmTransactor) TryFfi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "tryFfi", commandInput) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_Vm *VmSession) TryFfi(commandInput []string) (*types.Transaction, error) { + return _Vm.Contract.TryFfi(&_Vm.TransactOpts, commandInput) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_Vm *VmTransactorSession) TryFfi(commandInput []string) (*types.Transaction, error) { + return _Vm.Contract.TryFfi(&_Vm.TransactOpts, commandInput) +} + +// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f. +// +// Solidity: function txGasPrice(uint256 newGasPrice) returns() +func (_Vm *VmTransactor) TxGasPrice(opts *bind.TransactOpts, newGasPrice *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "txGasPrice", newGasPrice) +} + +// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f. +// +// Solidity: function txGasPrice(uint256 newGasPrice) returns() +func (_Vm *VmSession) TxGasPrice(newGasPrice *big.Int) (*types.Transaction, error) { + return _Vm.Contract.TxGasPrice(&_Vm.TransactOpts, newGasPrice) +} + +// TxGasPrice is a paid mutator transaction binding the contract method 0x48f50c0f. +// +// Solidity: function txGasPrice(uint256 newGasPrice) returns() +func (_Vm *VmTransactorSession) TxGasPrice(newGasPrice *big.Int) (*types.Transaction, error) { + return _Vm.Contract.TxGasPrice(&_Vm.TransactOpts, newGasPrice) +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_Vm *VmTransactor) UnixTime(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "unixTime") +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_Vm *VmSession) UnixTime() (*types.Transaction, error) { + return _Vm.Contract.UnixTime(&_Vm.TransactOpts) +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_Vm *VmTransactorSession) UnixTime() (*types.Transaction, error) { + return _Vm.Contract.UnixTime(&_Vm.TransactOpts) +} + +// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02. +// +// Solidity: function warp(uint256 newTimestamp) returns() +func (_Vm *VmTransactor) Warp(opts *bind.TransactOpts, newTimestamp *big.Int) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "warp", newTimestamp) +} + +// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02. +// +// Solidity: function warp(uint256 newTimestamp) returns() +func (_Vm *VmSession) Warp(newTimestamp *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Warp(&_Vm.TransactOpts, newTimestamp) +} + +// Warp is a paid mutator transaction binding the contract method 0xe5d6bf02. +// +// Solidity: function warp(uint256 newTimestamp) returns() +func (_Vm *VmTransactorSession) Warp(newTimestamp *big.Int) (*types.Transaction, error) { + return _Vm.Contract.Warp(&_Vm.TransactOpts, newTimestamp) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_Vm *VmTransactor) WriteFile(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeFile", path, data) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_Vm *VmSession) WriteFile(path string, data string) (*types.Transaction, error) { + return _Vm.Contract.WriteFile(&_Vm.TransactOpts, path, data) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_Vm *VmTransactorSession) WriteFile(path string, data string) (*types.Transaction, error) { + return _Vm.Contract.WriteFile(&_Vm.TransactOpts, path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_Vm *VmTransactor) WriteFileBinary(opts *bind.TransactOpts, path string, data []byte) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeFileBinary", path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_Vm *VmSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) { + return _Vm.Contract.WriteFileBinary(&_Vm.TransactOpts, path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_Vm *VmTransactorSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) { + return _Vm.Contract.WriteFileBinary(&_Vm.TransactOpts, path, data) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_Vm *VmTransactor) WriteJson(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeJson", json, path, valueKey) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_Vm *VmSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.Contract.WriteJson(&_Vm.TransactOpts, json, path, valueKey) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_Vm *VmTransactorSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.Contract.WriteJson(&_Vm.TransactOpts, json, path, valueKey) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_Vm *VmTransactor) WriteJson0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeJson0", json, path) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_Vm *VmSession) WriteJson0(json string, path string) (*types.Transaction, error) { + return _Vm.Contract.WriteJson0(&_Vm.TransactOpts, json, path) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_Vm *VmTransactorSession) WriteJson0(json string, path string) (*types.Transaction, error) { + return _Vm.Contract.WriteJson0(&_Vm.TransactOpts, json, path) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_Vm *VmTransactor) WriteLine(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeLine", path, data) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_Vm *VmSession) WriteLine(path string, data string) (*types.Transaction, error) { + return _Vm.Contract.WriteLine(&_Vm.TransactOpts, path, data) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_Vm *VmTransactorSession) WriteLine(path string, data string) (*types.Transaction, error) { + return _Vm.Contract.WriteLine(&_Vm.TransactOpts, path, data) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_Vm *VmTransactor) WriteToml(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeToml", json, path, valueKey) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_Vm *VmSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.Contract.WriteToml(&_Vm.TransactOpts, json, path, valueKey) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_Vm *VmTransactorSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) { + return _Vm.Contract.WriteToml(&_Vm.TransactOpts, json, path, valueKey) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_Vm *VmTransactor) WriteToml0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) { + return _Vm.contract.Transact(opts, "writeToml0", json, path) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_Vm *VmSession) WriteToml0(json string, path string) (*types.Transaction, error) { + return _Vm.Contract.WriteToml0(&_Vm.TransactOpts, json, path) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_Vm *VmTransactorSession) WriteToml0(json string, path string) (*types.Transaction, error) { + return _Vm.Contract.WriteToml0(&_Vm.TransactOpts, json, path) +} diff --git a/pkg/forge-std/vm.sol/vmsafe.go b/pkg/forge-std/vm.sol/vmsafe.go new file mode 100644 index 00000000..346ba31a --- /dev/null +++ b/pkg/forge-std/vm.sol/vmsafe.go @@ -0,0 +1,9136 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package vm + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// VmSafeAccountAccess is an auto generated low-level Go binding around an user-defined struct. +type VmSafeAccountAccess struct { + ChainInfo VmSafeChainInfo + Kind uint8 + Account common.Address + Accessor common.Address + Initialized bool + OldBalance *big.Int + NewBalance *big.Int + DeployedCode []byte + Value *big.Int + Data []byte + Reverted bool + StorageAccesses []VmSafeStorageAccess + Depth uint64 +} + +// VmSafeChainInfo is an auto generated low-level Go binding around an user-defined struct. +type VmSafeChainInfo struct { + ForkId *big.Int + ChainId *big.Int +} + +// VmSafeDirEntry is an auto generated low-level Go binding around an user-defined struct. +type VmSafeDirEntry struct { + ErrorMessage string + Path string + Depth uint64 + IsDir bool + IsSymlink bool +} + +// VmSafeEthGetLogs is an auto generated low-level Go binding around an user-defined struct. +type VmSafeEthGetLogs struct { + Emitter common.Address + Topics [][32]byte + Data []byte + BlockHash [32]byte + BlockNumber uint64 + TransactionHash [32]byte + TransactionIndex uint64 + LogIndex *big.Int + Removed bool +} + +// VmSafeFfiResult is an auto generated low-level Go binding around an user-defined struct. +type VmSafeFfiResult struct { + ExitCode int32 + Stdout []byte + Stderr []byte +} + +// VmSafeFsMetadata is an auto generated low-level Go binding around an user-defined struct. +type VmSafeFsMetadata struct { + IsDir bool + IsSymlink bool + Length *big.Int + ReadOnly bool + Modified *big.Int + Accessed *big.Int + Created *big.Int +} + +// VmSafeGas is an auto generated low-level Go binding around an user-defined struct. +type VmSafeGas struct { + GasLimit uint64 + GasTotalUsed uint64 + GasMemoryUsed uint64 + GasRefunded int64 + GasRemaining uint64 +} + +// VmSafeLog is an auto generated low-level Go binding around an user-defined struct. +type VmSafeLog struct { + Topics [][32]byte + Data []byte + Emitter common.Address +} + +// VmSafeRpc is an auto generated low-level Go binding around an user-defined struct. +type VmSafeRpc struct { + Key string + Url string +} + +// VmSafeStorageAccess is an auto generated low-level Go binding around an user-defined struct. +type VmSafeStorageAccess struct { + Account common.Address + Slot [32]byte + IsWrite bool + PreviousValue [32]byte + NewValue [32]byte + Reverted bool +} + +// VmSafeWallet is an auto generated low-level Go binding around an user-defined struct. +type VmSafeWallet struct { + Addr common.Address + PublicKeyX *big.Int + PublicKeyY *big.Int + PrivateKey *big.Int +} + +// VmSafeMetaData contains all meta data concerning the VmSafe contract. +var VmSafeMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"accesses\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"readSlots\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"writeSlots\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbs\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqAbsDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRel\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"maxPercentDelta\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertApproxEqRelDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertFalse\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertGtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLe\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLeDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertLt\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertLtDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"left\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"right\",\"type\":\"bool\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool[]\",\"name\":\"left\",\"type\":\"bool[]\"},{\"internalType\":\"bool[]\",\"name\":\"right\",\"type\":\"bool[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"left\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"right\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"left\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"right\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"left\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"right\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"left\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"right\",\"type\":\"uint256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"left\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"right\",\"type\":\"address\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"left\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"right\",\"type\":\"bytes32\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"left\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes32[]\",\"name\":\"right\",\"type\":\"bytes32[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"left\",\"type\":\"string[]\"},{\"internalType\":\"string[]\",\"name\":\"right\",\"type\":\"string[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256[]\",\"name\":\"left\",\"type\":\"int256[]\"},{\"internalType\":\"int256[]\",\"name\":\"right\",\"type\":\"int256[]\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"left\",\"type\":\"bytes[]\"},{\"internalType\":\"bytes[]\",\"name\":\"right\",\"type\":\"bytes[]\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"}],\"name\":\"assertNotEq\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"left\",\"type\":\"int256\"},{\"internalType\":\"int256\",\"name\":\"right\",\"type\":\"int256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"left\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"right\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertNotEqDecimal\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"},{\"internalType\":\"string\",\"name\":\"error\",\"type\":\"string\"}],\"name\":\"assertTrue\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"condition\",\"type\":\"bool\"}],\"name\":\"assume\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"char\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"breakpoint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"broadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"closeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"salt\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"initCodeHash\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"}],\"name\":\"computeCreate2Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"deployer\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"}],\"name\":\"computeCreateAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"copyFile\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"copied\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"createDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"string\",\"name\":\"walletLabel\",\"type\":\"string\"}],\"name\":\"createWallet\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"},{\"internalType\":\"string\",\"name\":\"language\",\"type\":\"string\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"mnemonic\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"derivationPath\",\"type\":\"string\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"name\":\"deriveKey\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"ensNamehash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envAddress\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBool\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"defaultValue\",\"type\":\"bytes32[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"value\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"defaultValue\",\"type\":\"int256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"value\",\"type\":\"int256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"defaultValue\",\"type\":\"bool\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"defaultValue\",\"type\":\"address\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"defaultValue\",\"type\":\"uint256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"defaultValue\",\"type\":\"bytes[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"value\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"defaultValue\",\"type\":\"uint256[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"defaultValue\",\"type\":\"string[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"defaultValue\",\"type\":\"bytes\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"defaultValue\",\"type\":\"bytes32\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"defaultValue\",\"type\":\"int256\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"defaultValue\",\"type\":\"address[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"value\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"defaultValue\",\"type\":\"string\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"defaultValue\",\"type\":\"bool[]\"}],\"name\":\"envOr\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"value\",\"type\":\"bool[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"value\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delim\",\"type\":\"string\"}],\"name\":\"envUint\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"value\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fromBlock\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"toBlock\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"}],\"name\":\"eth_getLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"},{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"blockHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"blockNumber\",\"type\":\"uint64\"},{\"internalType\":\"bytes32\",\"name\":\"transactionHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"transactionIndex\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"logIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"removed\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.EthGetLogs[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"exists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"ffi\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"result\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"fsMetadata\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"readOnly\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"modified\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"accessed\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"created\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.FsMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlobBaseFee\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"blobBaseFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"height\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getBlockTimestamp\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"creationBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"artifactPath\",\"type\":\"string\"}],\"name\":\"getDeployedCode\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"runtimeBytecode\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getLabel\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"currentLabel\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"elementSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingKeyAndParentOf\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"found\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"key\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"parent\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"}],\"name\":\"getMappingLength\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"mappingSlot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"idx\",\"type\":\"uint256\"}],\"name\":\"getMappingSlotAt\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"}],\"name\":\"getNonce\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRecordedLogs\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32[]\",\"name\":\"topics\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"emitter\",\"type\":\"address\"}],\"internalType\":\"structVmSafe.Log[]\",\"name\":\"logs\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"indexOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enumVmSafe.ForgeContext\",\"name\":\"context\",\"type\":\"uint8\"}],\"name\":\"isContext\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isDir\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"isFile\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"result\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExists\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsJson\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"keyExistsToml\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"newLabel\",\"type\":\"string\"}],\"name\":\"label\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lastCallGas\",\"outputs\":[{\"components\":[{\"internalType\":\"uint64\",\"name\":\"gasLimit\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasTotalUsed\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"gasMemoryUsed\",\"type\":\"uint64\"},{\"internalType\":\"int64\",\"name\":\"gasRefunded\",\"type\":\"int64\"},{\"internalType\":\"uint64\",\"name\":\"gasRemaining\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.Gas\",\"name\":\"gas\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"}],\"name\":\"load\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"data\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"parsedValue\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"parsedValue\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"parsedValue\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"parsedValue\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"parsedValue\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJson\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseJsonUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"}],\"name\":\"parseToml\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"abiEncodedData\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlAddressArray\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBool\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBoolArray\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"\",\"type\":\"bool[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytes32Array\",\"outputs\":[{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlBytesArray\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlInt\",\"outputs\":[{\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlIntArray\",\"outputs\":[{\"internalType\":\"int256[]\",\"name\":\"\",\"type\":\"int256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlKeys\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"keys\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlStringArray\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"toml\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"}],\"name\":\"parseTomlUintArray\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"name\":\"parseUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"parsedValue\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pauseGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"projectRoot\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"prompt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecret\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptSecretUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"promptText\",\"type\":\"string\"}],\"name\":\"promptUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"min\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"max\",\"type\":\"uint256\"}],\"name\":\"randomUint\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"maxDepth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"followLinks\",\"type\":\"bool\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readDir\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"errorMessage\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"},{\"internalType\":\"bool\",\"name\":\"isDir\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isSymlink\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.DirEntry[]\",\"name\":\"entries\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFile\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readFileBinary\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"readLine\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"line\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"linkPath\",\"type\":\"string\"}],\"name\":\"readLink\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"targetPath\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"record\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"recordLogs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"rememberKey\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"keyAddr\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"recursive\",\"type\":\"bool\"}],\"name\":\"removeDir\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"removeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"from\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"to\",\"type\":\"string\"}],\"name\":\"replace\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"resumeGasMetering\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"method\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"params\",\"type\":\"string\"}],\"name\":\"rpc\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"rpcAlias\",\"type\":\"string\"}],\"name\":\"rpcUrl\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrlStructs\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"url\",\"type\":\"string\"}],\"internalType\":\"structVmSafe.Rpc[]\",\"name\":\"urls\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rpcUrls\",\"outputs\":[{\"internalType\":\"string[2][]\",\"name\":\"urls\",\"type\":\"string[2][]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address[]\",\"name\":\"values\",\"type\":\"address[]\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"serializeAddress\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool[]\",\"name\":\"values\",\"type\":\"bool[]\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"serializeBool\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes[]\",\"name\":\"values\",\"type\":\"bytes[]\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"serializeBytes\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32[]\",\"name\":\"values\",\"type\":\"bytes32[]\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"serializeBytes32\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"int256[]\",\"name\":\"values\",\"type\":\"int256[]\"}],\"name\":\"serializeInt\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeJson\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string[]\",\"name\":\"values\",\"type\":\"string[]\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"serializeString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"serializeUint\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"objectKey\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"serializeUintToHex\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setEnv\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyX\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"publicKeyY\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.Wallet\",\"name\":\"wallet\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"sign\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"digest\",\"type\":\"bytes32\"}],\"name\":\"signP256\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"duration\",\"type\":\"uint256\"}],\"name\":\"sleep\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"delimiter\",\"type\":\"string\"}],\"name\":\"split\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"outputs\",\"type\":\"string[]\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"signer\",\"type\":\"address\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"privateKey\",\"type\":\"uint256\"}],\"name\":\"startBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"startStateDiffRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopAndReturnStateDiff\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"forkId\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"}],\"internalType\":\"structVmSafe.ChainInfo\",\"name\":\"chainInfo\",\"type\":\"tuple\"},{\"internalType\":\"enumVmSafe.AccountAccessKind\",\"name\":\"kind\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"accessor\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"initialized\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"oldBalance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"newBalance\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"deployedCode\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"slot\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"isWrite\",\"type\":\"bool\"},{\"internalType\":\"bytes32\",\"name\":\"previousValue\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"newValue\",\"type\":\"bytes32\"},{\"internalType\":\"bool\",\"name\":\"reverted\",\"type\":\"bool\"}],\"internalType\":\"structVmSafe.StorageAccess[]\",\"name\":\"storageAccesses\",\"type\":\"tuple[]\"},{\"internalType\":\"uint64\",\"name\":\"depth\",\"type\":\"uint64\"}],\"internalType\":\"structVmSafe.AccountAccess[]\",\"name\":\"accountAccesses\",\"type\":\"tuple[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopBroadcast\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stopMappingRecording\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"toBase64URL\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toLowercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"value\",\"type\":\"address\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"value\",\"type\":\"bytes\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"value\",\"type\":\"bool\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"int256\",\"name\":\"value\",\"type\":\"int256\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"value\",\"type\":\"bytes32\"}],\"name\":\"toString\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"stringifiedValue\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"toUppercase\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"input\",\"type\":\"string\"}],\"name\":\"trim\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"output\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string[]\",\"name\":\"commandInput\",\"type\":\"string[]\"}],\"name\":\"tryFfi\",\"outputs\":[{\"components\":[{\"internalType\":\"int32\",\"name\":\"exitCode\",\"type\":\"int32\"},{\"internalType\":\"bytes\",\"name\":\"stdout\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"stderr\",\"type\":\"bytes\"}],\"internalType\":\"structVmSafe.FfiResult\",\"name\":\"result\",\"type\":\"tuple\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unixTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"milliseconds\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeFile\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"writeFileBinary\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeJson\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"data\",\"type\":\"string\"}],\"name\":\"writeLine\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"valueKey\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"json\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"path\",\"type\":\"string\"}],\"name\":\"writeToml\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// VmSafeABI is the input ABI used to generate the binding from. +// Deprecated: Use VmSafeMetaData.ABI instead. +var VmSafeABI = VmSafeMetaData.ABI + +// VmSafe is an auto generated Go binding around an Ethereum contract. +type VmSafe struct { + VmSafeCaller // Read-only binding to the contract + VmSafeTransactor // Write-only binding to the contract + VmSafeFilterer // Log filterer for contract events +} + +// VmSafeCaller is an auto generated read-only Go binding around an Ethereum contract. +type VmSafeCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmSafeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type VmSafeTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmSafeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type VmSafeFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// VmSafeSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type VmSafeSession struct { + Contract *VmSafe // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// VmSafeCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type VmSafeCallerSession struct { + Contract *VmSafeCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// VmSafeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type VmSafeTransactorSession struct { + Contract *VmSafeTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// VmSafeRaw is an auto generated low-level Go binding around an Ethereum contract. +type VmSafeRaw struct { + Contract *VmSafe // Generic contract binding to access the raw methods on +} + +// VmSafeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type VmSafeCallerRaw struct { + Contract *VmSafeCaller // Generic read-only contract binding to access the raw methods on +} + +// VmSafeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type VmSafeTransactorRaw struct { + Contract *VmSafeTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewVmSafe creates a new instance of VmSafe, bound to a specific deployed contract. +func NewVmSafe(address common.Address, backend bind.ContractBackend) (*VmSafe, error) { + contract, err := bindVmSafe(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &VmSafe{VmSafeCaller: VmSafeCaller{contract: contract}, VmSafeTransactor: VmSafeTransactor{contract: contract}, VmSafeFilterer: VmSafeFilterer{contract: contract}}, nil +} + +// NewVmSafeCaller creates a new read-only instance of VmSafe, bound to a specific deployed contract. +func NewVmSafeCaller(address common.Address, caller bind.ContractCaller) (*VmSafeCaller, error) { + contract, err := bindVmSafe(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &VmSafeCaller{contract: contract}, nil +} + +// NewVmSafeTransactor creates a new write-only instance of VmSafe, bound to a specific deployed contract. +func NewVmSafeTransactor(address common.Address, transactor bind.ContractTransactor) (*VmSafeTransactor, error) { + contract, err := bindVmSafe(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &VmSafeTransactor{contract: contract}, nil +} + +// NewVmSafeFilterer creates a new log filterer instance of VmSafe, bound to a specific deployed contract. +func NewVmSafeFilterer(address common.Address, filterer bind.ContractFilterer) (*VmSafeFilterer, error) { + contract, err := bindVmSafe(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &VmSafeFilterer{contract: contract}, nil +} + +// bindVmSafe binds a generic wrapper to an already deployed contract. +func bindVmSafe(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := VmSafeMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_VmSafe *VmSafeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _VmSafe.Contract.VmSafeCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_VmSafe *VmSafeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.Contract.VmSafeTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_VmSafe *VmSafeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _VmSafe.Contract.VmSafeTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_VmSafe *VmSafeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _VmSafe.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_VmSafe *VmSafeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_VmSafe *VmSafeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _VmSafe.Contract.contract.Transact(opts, method, params...) +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_VmSafe *VmSafeCaller) Addr(opts *bind.CallOpts, privateKey *big.Int) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "addr", privateKey) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_VmSafe *VmSafeSession) Addr(privateKey *big.Int) (common.Address, error) { + return _VmSafe.Contract.Addr(&_VmSafe.CallOpts, privateKey) +} + +// Addr is a free data retrieval call binding the contract method 0xffa18649. +// +// Solidity: function addr(uint256 privateKey) pure returns(address keyAddr) +func (_VmSafe *VmSafeCallerSession) Addr(privateKey *big.Int) (common.Address, error) { + return _VmSafe.Contract.Addr(&_VmSafe.CallOpts, privateKey) +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbs(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs", left, right, maxDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbs(&_VmSafe.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs is a free data retrieval call binding the contract method 0x16d207c6. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbs(&_VmSafe.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbs0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs0", left, right, maxDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbs0(&_VmSafe.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs0 is a free data retrieval call binding the contract method 0x240f839d. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs0(left *big.Int, right *big.Int, maxDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbs0(&_VmSafe.CallOpts, left, right, maxDelta) +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbs1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs1", left, right, maxDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbs1(&_VmSafe.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs1 is a free data retrieval call binding the contract method 0x8289e621. +// +// Solidity: function assertApproxEqAbs(int256 left, int256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs1(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbs1(&_VmSafe.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbs2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbs2", left, right, maxDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbs2(&_VmSafe.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbs2 is a free data retrieval call binding the contract method 0xf710b062. +// +// Solidity: function assertApproxEqAbs(uint256 left, uint256 right, uint256 maxDelta, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbs2(left *big.Int, right *big.Int, maxDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbs2(&_VmSafe.CallOpts, left, right, maxDelta, error) +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal", left, right, maxDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal(&_VmSafe.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal is a free data retrieval call binding the contract method 0x045c55ce. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal(&_VmSafe.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal0", left, right, maxDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal0(&_VmSafe.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal0 is a free data retrieval call binding the contract method 0x3d5bc8bc. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal0(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal0(&_VmSafe.CallOpts, left, right, maxDelta, decimals) +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal1", left, right, maxDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal1(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal1 is a free data retrieval call binding the contract method 0x60429eb2. +// +// Solidity: function assertApproxEqAbsDecimal(uint256 left, uint256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal1(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal1(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqAbsDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqAbsDecimal2", left, right, maxDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal2(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqAbsDecimal2 is a free data retrieval call binding the contract method 0x6a5066d4. +// +// Solidity: function assertApproxEqAbsDecimal(int256 left, int256 right, uint256 maxDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqAbsDecimal2(left *big.Int, right *big.Int, maxDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqAbsDecimal2(&_VmSafe.CallOpts, left, right, maxDelta, decimals, error) +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRel(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel", left, right, maxPercentDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRel(&_VmSafe.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel is a free data retrieval call binding the contract method 0x1ecb7d33. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRel(&_VmSafe.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRel0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel0", left, right, maxPercentDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRel0(&_VmSafe.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel0 is a free data retrieval call binding the contract method 0x8cf25ef4. +// +// Solidity: function assertApproxEqRel(uint256 left, uint256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel0(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRel0(&_VmSafe.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRel1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel1", left, right, maxPercentDelta, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRel1(&_VmSafe.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel1 is a free data retrieval call binding the contract method 0xef277d72. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRel1(&_VmSafe.CallOpts, left, right, maxPercentDelta, error) +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRel2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRel2", left, right, maxPercentDelta) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRel2(&_VmSafe.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRel2 is a free data retrieval call binding the contract method 0xfea2d14f. +// +// Solidity: function assertApproxEqRel(int256 left, int256 right, uint256 maxPercentDelta) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRel2(left *big.Int, right *big.Int, maxPercentDelta *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRel2(&_VmSafe.CallOpts, left, right, maxPercentDelta) +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal", left, right, maxPercentDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal is a free data retrieval call binding the contract method 0x21ed2977. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal0", left, right, maxPercentDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal0(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal0 is a free data retrieval call binding the contract method 0x82d6c8fd. +// +// Solidity: function assertApproxEqRelDecimal(uint256 left, uint256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal0(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal0(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal1", left, right, maxPercentDelta, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal1(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal1 is a free data retrieval call binding the contract method 0xabbf21cc. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal1(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal1(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals) +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertApproxEqRelDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertApproxEqRelDecimal2", left, right, maxPercentDelta, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal2(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertApproxEqRelDecimal2 is a free data retrieval call binding the contract method 0xfccc11c4. +// +// Solidity: function assertApproxEqRelDecimal(int256 left, int256 right, uint256 maxPercentDelta, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertApproxEqRelDecimal2(left *big.Int, right *big.Int, maxPercentDelta *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertApproxEqRelDecimal2(&_VmSafe.CallOpts, left, right, maxPercentDelta, decimals, error) +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq(left [][32]byte, right [][32]byte) error { + return _VmSafe.Contract.AssertEq(&_VmSafe.CallOpts, left, right) +} + +// AssertEq is a free data retrieval call binding the contract method 0x0cc9ee84. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq(left [][32]byte, right [][32]byte) error { + return _VmSafe.Contract.AssertEq(&_VmSafe.CallOpts, left, right) +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertEq0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq0 is a free data retrieval call binding the contract method 0x191f1b30. +// +// Solidity: function assertEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq0(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertEq0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq1(opts *bind.CallOpts, left common.Address, right common.Address, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq1(left common.Address, right common.Address, error string) error { + return _VmSafe.Contract.AssertEq1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq1 is a free data retrieval call binding the contract method 0x2f2769d1. +// +// Solidity: function assertEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq1(left common.Address, right common.Address, error string) error { + return _VmSafe.Contract.AssertEq1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq10(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq10", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq10(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertEq10(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq10 is a free data retrieval call binding the contract method 0x714a2f13. +// +// Solidity: function assertEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq10(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertEq10(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq11(opts *bind.CallOpts, left [32]byte, right [32]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq11", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq11(left [32]byte, right [32]byte) error { + return _VmSafe.Contract.AssertEq11(&_VmSafe.CallOpts, left, right) +} + +// AssertEq11 is a free data retrieval call binding the contract method 0x7c84c69b. +// +// Solidity: function assertEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq11(left [32]byte, right [32]byte) error { + return _VmSafe.Contract.AssertEq11(&_VmSafe.CallOpts, left, right) +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq12(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq12", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq12(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertEq12(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq12 is a free data retrieval call binding the contract method 0x88b44c85. +// +// Solidity: function assertEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq12(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertEq12(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq13(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq13", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq13(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertEq13(&_VmSafe.CallOpts, left, right) +} + +// AssertEq13 is a free data retrieval call binding the contract method 0x975d5a12. +// +// Solidity: function assertEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq13(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertEq13(&_VmSafe.CallOpts, left, right) +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq14(opts *bind.CallOpts, left []byte, right []byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq14", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq14(left []byte, right []byte) error { + return _VmSafe.Contract.AssertEq14(&_VmSafe.CallOpts, left, right) +} + +// AssertEq14 is a free data retrieval call binding the contract method 0x97624631. +// +// Solidity: function assertEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq14(left []byte, right []byte) error { + return _VmSafe.Contract.AssertEq14(&_VmSafe.CallOpts, left, right) +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq15(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq15", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq15(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertEq15(&_VmSafe.CallOpts, left, right) +} + +// AssertEq15 is a free data retrieval call binding the contract method 0x98296c54. +// +// Solidity: function assertEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq15(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertEq15(&_VmSafe.CallOpts, left, right) +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq16(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq16", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq16(left [32]byte, right [32]byte, error string) error { + return _VmSafe.Contract.AssertEq16(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq16 is a free data retrieval call binding the contract method 0xc1fa1ed0. +// +// Solidity: function assertEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq16(left [32]byte, right [32]byte, error string) error { + return _VmSafe.Contract.AssertEq16(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq17(opts *bind.CallOpts, left []string, right []string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq17", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq17(left []string, right []string) error { + return _VmSafe.Contract.AssertEq17(&_VmSafe.CallOpts, left, right) +} + +// AssertEq17 is a free data retrieval call binding the contract method 0xcf1c049c. +// +// Solidity: function assertEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq17(left []string, right []string) error { + return _VmSafe.Contract.AssertEq17(&_VmSafe.CallOpts, left, right) +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq18(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq18", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error { + return _VmSafe.Contract.AssertEq18(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq18 is a free data retrieval call binding the contract method 0xe03e9177. +// +// Solidity: function assertEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq18(left [][32]byte, right [][32]byte, error string) error { + return _VmSafe.Contract.AssertEq18(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq19(opts *bind.CallOpts, left []byte, right []byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq19", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq19(left []byte, right []byte, error string) error { + return _VmSafe.Contract.AssertEq19(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq19 is a free data retrieval call binding the contract method 0xe24fed00. +// +// Solidity: function assertEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq19(left []byte, right []byte, error string) error { + return _VmSafe.Contract.AssertEq19(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq2(opts *bind.CallOpts, left string, right string, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq2(left string, right string, error string) error { + return _VmSafe.Contract.AssertEq2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq2 is a free data retrieval call binding the contract method 0x36f656d8. +// +// Solidity: function assertEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq2(left string, right string, error string) error { + return _VmSafe.Contract.AssertEq2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq20(opts *bind.CallOpts, left []bool, right []bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq20", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq20(left []bool, right []bool, error string) error { + return _VmSafe.Contract.AssertEq20(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq20 is a free data retrieval call binding the contract method 0xe48a8f8d. +// +// Solidity: function assertEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq20(left []bool, right []bool, error string) error { + return _VmSafe.Contract.AssertEq20(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq21(opts *bind.CallOpts, left [][]byte, right [][]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq21", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq21(left [][]byte, right [][]byte) error { + return _VmSafe.Contract.AssertEq21(&_VmSafe.CallOpts, left, right) +} + +// AssertEq21 is a free data retrieval call binding the contract method 0xe5fb9b4a. +// +// Solidity: function assertEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq21(left [][]byte, right [][]byte) error { + return _VmSafe.Contract.AssertEq21(&_VmSafe.CallOpts, left, right) +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq22(opts *bind.CallOpts, left []string, right []string, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq22", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq22(left []string, right []string, error string) error { + return _VmSafe.Contract.AssertEq22(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq22 is a free data retrieval call binding the contract method 0xeff6b27d. +// +// Solidity: function assertEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq22(left []string, right []string, error string) error { + return _VmSafe.Contract.AssertEq22(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq23(opts *bind.CallOpts, left string, right string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq23", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq23(left string, right string) error { + return _VmSafe.Contract.AssertEq23(&_VmSafe.CallOpts, left, right) +} + +// AssertEq23 is a free data retrieval call binding the contract method 0xf320d963. +// +// Solidity: function assertEq(string left, string right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq23(left string, right string) error { + return _VmSafe.Contract.AssertEq23(&_VmSafe.CallOpts, left, right) +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq24(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq24", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq24(left [][]byte, right [][]byte, error string) error { + return _VmSafe.Contract.AssertEq24(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq24 is a free data retrieval call binding the contract method 0xf413f0b6. +// +// Solidity: function assertEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq24(left [][]byte, right [][]byte, error string) error { + return _VmSafe.Contract.AssertEq24(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq25(opts *bind.CallOpts, left bool, right bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq25", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq25(left bool, right bool) error { + return _VmSafe.Contract.AssertEq25(&_VmSafe.CallOpts, left, right) +} + +// AssertEq25 is a free data retrieval call binding the contract method 0xf7fe3477. +// +// Solidity: function assertEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq25(left bool, right bool) error { + return _VmSafe.Contract.AssertEq25(&_VmSafe.CallOpts, left, right) +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq26", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq26(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertEq26(&_VmSafe.CallOpts, left, right) +} + +// AssertEq26 is a free data retrieval call binding the contract method 0xfe74f05b. +// +// Solidity: function assertEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq26(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertEq26(&_VmSafe.CallOpts, left, right) +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq3(opts *bind.CallOpts, left []common.Address, right []common.Address) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq3", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq3(left []common.Address, right []common.Address) error { + return _VmSafe.Contract.AssertEq3(&_VmSafe.CallOpts, left, right) +} + +// AssertEq3 is a free data retrieval call binding the contract method 0x3868ac34. +// +// Solidity: function assertEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq3(left []common.Address, right []common.Address) error { + return _VmSafe.Contract.AssertEq3(&_VmSafe.CallOpts, left, right) +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq4(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq4", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq4(left []common.Address, right []common.Address, error string) error { + return _VmSafe.Contract.AssertEq4(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq4 is a free data retrieval call binding the contract method 0x3e9173c5. +// +// Solidity: function assertEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq4(left []common.Address, right []common.Address, error string) error { + return _VmSafe.Contract.AssertEq4(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq5(opts *bind.CallOpts, left bool, right bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq5", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq5(left bool, right bool, error string) error { + return _VmSafe.Contract.AssertEq5(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq5 is a free data retrieval call binding the contract method 0x4db19e7e. +// +// Solidity: function assertEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq5(left bool, right bool, error string) error { + return _VmSafe.Contract.AssertEq5(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq6(opts *bind.CallOpts, left common.Address, right common.Address) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq6", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq6(left common.Address, right common.Address) error { + return _VmSafe.Contract.AssertEq6(&_VmSafe.CallOpts, left, right) +} + +// AssertEq6 is a free data retrieval call binding the contract method 0x515361f6. +// +// Solidity: function assertEq(address left, address right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq6(left common.Address, right common.Address) error { + return _VmSafe.Contract.AssertEq6(&_VmSafe.CallOpts, left, right) +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq7(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq7", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertEq7(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq7 is a free data retrieval call binding the contract method 0x5d18c73a. +// +// Solidity: function assertEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq7(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertEq7(&_VmSafe.CallOpts, left, right, error) +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq8(opts *bind.CallOpts, left []bool, right []bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq8", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq8(left []bool, right []bool) error { + return _VmSafe.Contract.AssertEq8(&_VmSafe.CallOpts, left, right) +} + +// AssertEq8 is a free data retrieval call binding the contract method 0x707df785. +// +// Solidity: function assertEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq8(left []bool, right []bool) error { + return _VmSafe.Contract.AssertEq8(&_VmSafe.CallOpts, left, right) +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertEq9(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEq9", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertEq9(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertEq9(&_VmSafe.CallOpts, left, right) +} + +// AssertEq9 is a free data retrieval call binding the contract method 0x711043ac. +// +// Solidity: function assertEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEq9(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertEq9(&_VmSafe.CallOpts, left, right) +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertEqDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertEqDecimal is a free data retrieval call binding the contract method 0x27af7d9c. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertEqDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal0", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertEqDecimal0(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertEqDecimal0 is a free data retrieval call binding the contract method 0x48016c04. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertEqDecimal0(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertEqDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal1 is a free data retrieval call binding the contract method 0x7e77b0c5. +// +// Solidity: function assertEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertEqDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertEqDecimal2", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertEqDecimal2 is a free data retrieval call binding the contract method 0xd0cbbdef. +// +// Solidity: function assertEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertFalse(opts *bind.CallOpts, condition bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertFalse", condition, error) + + if err != nil { + return err + } + + return err + +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertFalse(condition bool, error string) error { + return _VmSafe.Contract.AssertFalse(&_VmSafe.CallOpts, condition, error) +} + +// AssertFalse is a free data retrieval call binding the contract method 0x7ba04809. +// +// Solidity: function assertFalse(bool condition, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertFalse(condition bool, error string) error { + return _VmSafe.Contract.AssertFalse(&_VmSafe.CallOpts, condition, error) +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_VmSafe *VmSafeCaller) AssertFalse0(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertFalse0", condition) + + if err != nil { + return err + } + + return err + +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_VmSafe *VmSafeSession) AssertFalse0(condition bool) error { + return _VmSafe.Contract.AssertFalse0(&_VmSafe.CallOpts, condition) +} + +// AssertFalse0 is a free data retrieval call binding the contract method 0xa5982885. +// +// Solidity: function assertFalse(bool condition) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertFalse0(condition bool) error { + return _VmSafe.Contract.AssertFalse0(&_VmSafe.CallOpts, condition) +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertGe(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGe", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertGe(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGe(&_VmSafe.CallOpts, left, right) +} + +// AssertGe is a free data retrieval call binding the contract method 0x0a30b771. +// +// Solidity: function assertGe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGe(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGe(&_VmSafe.CallOpts, left, right) +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGe0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGe0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGe0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGe0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGe0 is a free data retrieval call binding the contract method 0xa84328dd. +// +// Solidity: function assertGe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGe0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGe0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertGe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGe1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertGe1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGe1(&_VmSafe.CallOpts, left, right) +} + +// AssertGe1 is a free data retrieval call binding the contract method 0xa8d4d1d9. +// +// Solidity: function assertGe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGe1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGe1(&_VmSafe.CallOpts, left, right) +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGe2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGe2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGe2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGe2 is a free data retrieval call binding the contract method 0xe25242c0. +// +// Solidity: function assertGe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGe2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGe2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertGeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGeDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGeDecimal is a free data retrieval call binding the contract method 0x3d1fe08a. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGeDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal0 is a free data retrieval call binding the contract method 0x5df93c9b. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal1 is a free data retrieval call binding the contract method 0x8bff9133. +// +// Solidity: function assertGeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertGeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGeDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGeDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGeDecimal2 is a free data retrieval call binding the contract method 0xdc28c0f1. +// +// Solidity: function assertGeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGeDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertGt(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGt", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertGt(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGt(&_VmSafe.CallOpts, left, right) +} + +// AssertGt is a free data retrieval call binding the contract method 0x5a362d45. +// +// Solidity: function assertGt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGt(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGt(&_VmSafe.CallOpts, left, right) +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGt0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGt0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGt0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGt0 is a free data retrieval call binding the contract method 0xd9a3c4d2. +// +// Solidity: function assertGt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGt0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGt0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertGt1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGt1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertGt1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGt1(&_VmSafe.CallOpts, left, right) +} + +// AssertGt1 is a free data retrieval call binding the contract method 0xdb07fcd2. +// +// Solidity: function assertGt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGt1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertGt1(&_VmSafe.CallOpts, left, right) +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGt2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGt2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGt2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGt2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGt2 is a free data retrieval call binding the contract method 0xf8d33b9b. +// +// Solidity: function assertGt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGt2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertGt2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGtDecimal(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal is a free data retrieval call binding the contract method 0x04a5c7ab. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGtDecimal(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGtDecimal(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertGtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal0 is a free data retrieval call binding the contract method 0x64949a8d. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertGtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertGtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal1", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGtDecimal1(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGtDecimal1 is a free data retrieval call binding the contract method 0x78611f0e. +// +// Solidity: function assertGtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGtDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGtDecimal1(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertGtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertGtDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGtDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertGtDecimal2 is a free data retrieval call binding the contract method 0xeccd2437. +// +// Solidity: function assertGtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertGtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertGtDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLe(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLe", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLe(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLe(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLe is a free data retrieval call binding the contract method 0x4dfe692c. +// +// Solidity: function assertLe(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLe(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLe(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertLe0(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLe0", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertLe0(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLe0(&_VmSafe.CallOpts, left, right) +} + +// AssertLe0 is a free data retrieval call binding the contract method 0x8466f415. +// +// Solidity: function assertLe(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLe0(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLe0(&_VmSafe.CallOpts, left, right) +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertLe1(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLe1", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertLe1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLe1(&_VmSafe.CallOpts, left, right) +} + +// AssertLe1 is a free data retrieval call binding the contract method 0x95fd154e. +// +// Solidity: function assertLe(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLe1(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLe1(&_VmSafe.CallOpts, left, right) +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLe2(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLe2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLe2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLe2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLe2 is a free data retrieval call binding the contract method 0xd17d4b0d. +// +// Solidity: function assertLe(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLe2(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLe2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertLeDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLeDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLeDecimal is a free data retrieval call binding the contract method 0x11d1364a. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLeDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLeDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLeDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal0 is a free data retrieval call binding the contract method 0x7fefbbe0. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLeDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLeDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLeDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal1 is a free data retrieval call binding the contract method 0xaa5cf788. +// +// Solidity: function assertLeDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLeDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLeDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertLeDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLeDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLeDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLeDecimal2 is a free data retrieval call binding the contract method 0xc304aab7. +// +// Solidity: function assertLeDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLeDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLeDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertLt(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLt", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertLt(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLt(&_VmSafe.CallOpts, left, right) +} + +// AssertLt is a free data retrieval call binding the contract method 0x3e914080. +// +// Solidity: function assertLt(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLt(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLt(&_VmSafe.CallOpts, left, right) +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLt0(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLt0", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLt0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLt0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLt0 is a free data retrieval call binding the contract method 0x65d5c135. +// +// Solidity: function assertLt(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLt0(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLt0(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLt1(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLt1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLt1(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLt1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLt1 is a free data retrieval call binding the contract method 0x9ff531e3. +// +// Solidity: function assertLt(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLt1(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertLt1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertLt2(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLt2", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertLt2(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLt2(&_VmSafe.CallOpts, left, right) +} + +// AssertLt2 is a free data retrieval call binding the contract method 0xb12fc005. +// +// Solidity: function assertLt(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLt2(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertLt2(&_VmSafe.CallOpts, left, right) +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertLtDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLtDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLtDecimal is a free data retrieval call binding the contract method 0x2077337e. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLtDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLtDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLtDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal0 is a free data retrieval call binding the contract method 0x40f0b4e0. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLtDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLtDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertLtDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal1", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLtDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal1 is a free data retrieval call binding the contract method 0xa972d037. +// +// Solidity: function assertLtDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLtDecimal1(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertLtDecimal1(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertLtDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertLtDecimal2", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLtDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertLtDecimal2 is a free data retrieval call binding the contract method 0xdbe8d88b. +// +// Solidity: function assertLtDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertLtDecimal2(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertLtDecimal2(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq(opts *bind.CallOpts, left [][32]byte, right [][32]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq(left [][32]byte, right [][32]byte) error { + return _VmSafe.Contract.AssertNotEq(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq is a free data retrieval call binding the contract method 0x0603ea68. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq(left [][32]byte, right [][32]byte) error { + return _VmSafe.Contract.AssertNotEq(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq0(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq0", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq0(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertNotEq0(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq0 is a free data retrieval call binding the contract method 0x0b72f4ef. +// +// Solidity: function assertNotEq(int256[] left, int256[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq0(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertNotEq0(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq1(opts *bind.CallOpts, left bool, right bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq1", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq1(left bool, right bool, error string) error { + return _VmSafe.Contract.AssertNotEq1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq1 is a free data retrieval call binding the contract method 0x1091a261. +// +// Solidity: function assertNotEq(bool left, bool right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq1(left bool, right bool, error string) error { + return _VmSafe.Contract.AssertNotEq1(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq10(opts *bind.CallOpts, left string, right string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq10", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq10(left string, right string) error { + return _VmSafe.Contract.AssertNotEq10(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq10 is a free data retrieval call binding the contract method 0x6a8237b3. +// +// Solidity: function assertNotEq(string left, string right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq10(left string, right string) error { + return _VmSafe.Contract.AssertNotEq10(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq11(opts *bind.CallOpts, left []common.Address, right []common.Address, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq11", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error { + return _VmSafe.Contract.AssertNotEq11(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq11 is a free data retrieval call binding the contract method 0x72c7e0b5. +// +// Solidity: function assertNotEq(address[] left, address[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq11(left []common.Address, right []common.Address, error string) error { + return _VmSafe.Contract.AssertNotEq11(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq12(opts *bind.CallOpts, left string, right string, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq12", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq12(left string, right string, error string) error { + return _VmSafe.Contract.AssertNotEq12(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq12 is a free data retrieval call binding the contract method 0x78bdcea7. +// +// Solidity: function assertNotEq(string left, string right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq12(left string, right string, error string) error { + return _VmSafe.Contract.AssertNotEq12(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq13(opts *bind.CallOpts, left common.Address, right common.Address, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq13", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq13(left common.Address, right common.Address, error string) error { + return _VmSafe.Contract.AssertNotEq13(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq13 is a free data retrieval call binding the contract method 0x8775a591. +// +// Solidity: function assertNotEq(address left, address right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq13(left common.Address, right common.Address, error string) error { + return _VmSafe.Contract.AssertNotEq13(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq14(opts *bind.CallOpts, left [32]byte, right [32]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq14", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq14(left [32]byte, right [32]byte) error { + return _VmSafe.Contract.AssertNotEq14(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq14 is a free data retrieval call binding the contract method 0x898e83fc. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq14(left [32]byte, right [32]byte) error { + return _VmSafe.Contract.AssertNotEq14(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq15(opts *bind.CallOpts, left []byte, right []byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq15", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq15(left []byte, right []byte, error string) error { + return _VmSafe.Contract.AssertNotEq15(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq15 is a free data retrieval call binding the contract method 0x9507540e. +// +// Solidity: function assertNotEq(bytes left, bytes right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq15(left []byte, right []byte, error string) error { + return _VmSafe.Contract.AssertNotEq15(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq16(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq16", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq16(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq16 is a free data retrieval call binding the contract method 0x98f9bdbd. +// +// Solidity: function assertNotEq(uint256 left, uint256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq16(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq16(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq17(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq17", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq17(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq17 is a free data retrieval call binding the contract method 0x9a7fbd8f. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq17(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq17(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq18(opts *bind.CallOpts, left common.Address, right common.Address) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq18", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq18(left common.Address, right common.Address) error { + return _VmSafe.Contract.AssertNotEq18(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq18 is a free data retrieval call binding the contract method 0xb12e1694. +// +// Solidity: function assertNotEq(address left, address right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq18(left common.Address, right common.Address) error { + return _VmSafe.Contract.AssertNotEq18(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq19(opts *bind.CallOpts, left [32]byte, right [32]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq19", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error { + return _VmSafe.Contract.AssertNotEq19(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq19 is a free data retrieval call binding the contract method 0xb2332f51. +// +// Solidity: function assertNotEq(bytes32 left, bytes32 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq19(left [32]byte, right [32]byte, error string) error { + return _VmSafe.Contract.AssertNotEq19(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq2(opts *bind.CallOpts, left [][]byte, right [][]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq2", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error { + return _VmSafe.Contract.AssertNotEq2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq2 is a free data retrieval call binding the contract method 0x1dcd1f68. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq2(left [][]byte, right [][]byte, error string) error { + return _VmSafe.Contract.AssertNotEq2(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq20(opts *bind.CallOpts, left []string, right []string, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq20", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq20(left []string, right []string, error string) error { + return _VmSafe.Contract.AssertNotEq20(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq20 is a free data retrieval call binding the contract method 0xb67187f3. +// +// Solidity: function assertNotEq(string[] left, string[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq20(left []string, right []string, error string) error { + return _VmSafe.Contract.AssertNotEq20(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq21(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq21", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq21(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertNotEq21(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq21 is a free data retrieval call binding the contract method 0xb7909320. +// +// Solidity: function assertNotEq(uint256 left, uint256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq21(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertNotEq21(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq22(opts *bind.CallOpts, left [][32]byte, right [][32]byte, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq22", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error { + return _VmSafe.Contract.AssertNotEq22(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq22 is a free data retrieval call binding the contract method 0xb873634c. +// +// Solidity: function assertNotEq(bytes32[] left, bytes32[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq22(left [][32]byte, right [][32]byte, error string) error { + return _VmSafe.Contract.AssertNotEq22(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq23(opts *bind.CallOpts, left []string, right []string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq23", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq23(left []string, right []string) error { + return _VmSafe.Contract.AssertNotEq23(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq23 is a free data retrieval call binding the contract method 0xbdfacbe8. +// +// Solidity: function assertNotEq(string[] left, string[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq23(left []string, right []string) error { + return _VmSafe.Contract.AssertNotEq23(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq24(opts *bind.CallOpts, left []*big.Int, right []*big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq24", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq24(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq24 is a free data retrieval call binding the contract method 0xd3977322. +// +// Solidity: function assertNotEq(int256[] left, int256[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq24(left []*big.Int, right []*big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq24(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq25(opts *bind.CallOpts, left [][]byte, right [][]byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq25", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq25(left [][]byte, right [][]byte) error { + return _VmSafe.Contract.AssertNotEq25(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq25 is a free data retrieval call binding the contract method 0xedecd035. +// +// Solidity: function assertNotEq(bytes[] left, bytes[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq25(left [][]byte, right [][]byte) error { + return _VmSafe.Contract.AssertNotEq25(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq26(opts *bind.CallOpts, left *big.Int, right *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq26", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq26(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertNotEq26(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq26 is a free data retrieval call binding the contract method 0xf4c004e3. +// +// Solidity: function assertNotEq(int256 left, int256 right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq26(left *big.Int, right *big.Int) error { + return _VmSafe.Contract.AssertNotEq26(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq3(opts *bind.CallOpts, left bool, right bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq3", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq3(left bool, right bool) error { + return _VmSafe.Contract.AssertNotEq3(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq3 is a free data retrieval call binding the contract method 0x236e4d66. +// +// Solidity: function assertNotEq(bool left, bool right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq3(left bool, right bool) error { + return _VmSafe.Contract.AssertNotEq3(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq4(opts *bind.CallOpts, left []bool, right []bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq4", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq4(left []bool, right []bool) error { + return _VmSafe.Contract.AssertNotEq4(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq4 is a free data retrieval call binding the contract method 0x286fafea. +// +// Solidity: function assertNotEq(bool[] left, bool[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq4(left []bool, right []bool) error { + return _VmSafe.Contract.AssertNotEq4(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq5(opts *bind.CallOpts, left []byte, right []byte) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq5", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq5(left []byte, right []byte) error { + return _VmSafe.Contract.AssertNotEq5(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq5 is a free data retrieval call binding the contract method 0x3cf78e28. +// +// Solidity: function assertNotEq(bytes left, bytes right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq5(left []byte, right []byte) error { + return _VmSafe.Contract.AssertNotEq5(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq6(opts *bind.CallOpts, left []common.Address, right []common.Address) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq6", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq6(left []common.Address, right []common.Address) error { + return _VmSafe.Contract.AssertNotEq6(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq6 is a free data retrieval call binding the contract method 0x46d0b252. +// +// Solidity: function assertNotEq(address[] left, address[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq6(left []common.Address, right []common.Address) error { + return _VmSafe.Contract.AssertNotEq6(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq7(opts *bind.CallOpts, left *big.Int, right *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq7", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq7(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq7 is a free data retrieval call binding the contract method 0x4724c5b9. +// +// Solidity: function assertNotEq(int256 left, int256 right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq7(left *big.Int, right *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEq7(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq8(opts *bind.CallOpts, left []*big.Int, right []*big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq8", left, right) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq8(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertNotEq8(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq8 is a free data retrieval call binding the contract method 0x56f29cba. +// +// Solidity: function assertNotEq(uint256[] left, uint256[] right) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq8(left []*big.Int, right []*big.Int) error { + return _VmSafe.Contract.AssertNotEq8(&_VmSafe.CallOpts, left, right) +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEq9(opts *bind.CallOpts, left []bool, right []bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEq9", left, right, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEq9(left []bool, right []bool, error string) error { + return _VmSafe.Contract.AssertNotEq9(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEq9 is a free data retrieval call binding the contract method 0x62c6f9fb. +// +// Solidity: function assertNotEq(bool[] left, bool[] right, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEq9(left []bool, right []bool, error string) error { + return _VmSafe.Contract.AssertNotEq9(&_VmSafe.CallOpts, left, right, error) +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEqDecimal(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertNotEqDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal is a free data retrieval call binding the contract method 0x14e75680. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertNotEqDecimal(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEqDecimal0(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal0", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEqDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal0 is a free data retrieval call binding the contract method 0x33949f0b. +// +// Solidity: function assertNotEqDecimal(int256 left, int256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal0(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEqDecimal0(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEqDecimal1(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal1", left, right, decimals) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertNotEqDecimal1(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal1 is a free data retrieval call binding the contract method 0x669efca7. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal1(left *big.Int, right *big.Int, decimals *big.Int) error { + return _VmSafe.Contract.AssertNotEqDecimal1(&_VmSafe.CallOpts, left, right, decimals) +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertNotEqDecimal2(opts *bind.CallOpts, left *big.Int, right *big.Int, decimals *big.Int, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertNotEqDecimal2", left, right, decimals, error) + + if err != nil { + return err + } + + return err + +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertNotEqDecimal2 is a free data retrieval call binding the contract method 0xf5a55558. +// +// Solidity: function assertNotEqDecimal(uint256 left, uint256 right, uint256 decimals, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertNotEqDecimal2(left *big.Int, right *big.Int, decimals *big.Int, error string) error { + return _VmSafe.Contract.AssertNotEqDecimal2(&_VmSafe.CallOpts, left, right, decimals, error) +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_VmSafe *VmSafeCaller) AssertTrue(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertTrue", condition) + + if err != nil { + return err + } + + return err + +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_VmSafe *VmSafeSession) AssertTrue(condition bool) error { + return _VmSafe.Contract.AssertTrue(&_VmSafe.CallOpts, condition) +} + +// AssertTrue is a free data retrieval call binding the contract method 0x0c9fd581. +// +// Solidity: function assertTrue(bool condition) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertTrue(condition bool) error { + return _VmSafe.Contract.AssertTrue(&_VmSafe.CallOpts, condition) +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_VmSafe *VmSafeCaller) AssertTrue0(opts *bind.CallOpts, condition bool, error string) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assertTrue0", condition, error) + + if err != nil { + return err + } + + return err + +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_VmSafe *VmSafeSession) AssertTrue0(condition bool, error string) error { + return _VmSafe.Contract.AssertTrue0(&_VmSafe.CallOpts, condition, error) +} + +// AssertTrue0 is a free data retrieval call binding the contract method 0xa34edc03. +// +// Solidity: function assertTrue(bool condition, string error) pure returns() +func (_VmSafe *VmSafeCallerSession) AssertTrue0(condition bool, error string) error { + return _VmSafe.Contract.AssertTrue0(&_VmSafe.CallOpts, condition, error) +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_VmSafe *VmSafeCaller) Assume(opts *bind.CallOpts, condition bool) error { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "assume", condition) + + if err != nil { + return err + } + + return err + +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_VmSafe *VmSafeSession) Assume(condition bool) error { + return _VmSafe.Contract.Assume(&_VmSafe.CallOpts, condition) +} + +// Assume is a free data retrieval call binding the contract method 0x4c63e562. +// +// Solidity: function assume(bool condition) pure returns() +func (_VmSafe *VmSafeCallerSession) Assume(condition bool) error { + return _VmSafe.Contract.Assume(&_VmSafe.CallOpts, condition) +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_VmSafe *VmSafeCaller) ComputeCreate2Address(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "computeCreate2Address", salt, initCodeHash) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_VmSafe *VmSafeSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + return _VmSafe.Contract.ComputeCreate2Address(&_VmSafe.CallOpts, salt, initCodeHash) +} + +// ComputeCreate2Address is a free data retrieval call binding the contract method 0x890c283b. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) pure returns(address) +func (_VmSafe *VmSafeCallerSession) ComputeCreate2Address(salt [32]byte, initCodeHash [32]byte) (common.Address, error) { + return _VmSafe.Contract.ComputeCreate2Address(&_VmSafe.CallOpts, salt, initCodeHash) +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_VmSafe *VmSafeCaller) ComputeCreate2Address0(opts *bind.CallOpts, salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "computeCreate2Address0", salt, initCodeHash, deployer) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_VmSafe *VmSafeSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + return _VmSafe.Contract.ComputeCreate2Address0(&_VmSafe.CallOpts, salt, initCodeHash, deployer) +} + +// ComputeCreate2Address0 is a free data retrieval call binding the contract method 0xd323826a. +// +// Solidity: function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer) pure returns(address) +func (_VmSafe *VmSafeCallerSession) ComputeCreate2Address0(salt [32]byte, initCodeHash [32]byte, deployer common.Address) (common.Address, error) { + return _VmSafe.Contract.ComputeCreate2Address0(&_VmSafe.CallOpts, salt, initCodeHash, deployer) +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_VmSafe *VmSafeCaller) ComputeCreateAddress(opts *bind.CallOpts, deployer common.Address, nonce *big.Int) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "computeCreateAddress", deployer, nonce) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_VmSafe *VmSafeSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) { + return _VmSafe.Contract.ComputeCreateAddress(&_VmSafe.CallOpts, deployer, nonce) +} + +// ComputeCreateAddress is a free data retrieval call binding the contract method 0x74637a7a. +// +// Solidity: function computeCreateAddress(address deployer, uint256 nonce) pure returns(address) +func (_VmSafe *VmSafeCallerSession) ComputeCreateAddress(deployer common.Address, nonce *big.Int) (common.Address, error) { + return _VmSafe.Contract.ComputeCreateAddress(&_VmSafe.CallOpts, deployer, nonce) +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCaller) DeriveKey(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "deriveKey", mnemonic, derivationPath, index, language) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey(&_VmSafe.CallOpts, mnemonic, derivationPath, index, language) +} + +// DeriveKey is a free data retrieval call binding the contract method 0x29233b1f. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCallerSession) DeriveKey(mnemonic string, derivationPath string, index uint32, language string) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey(&_VmSafe.CallOpts, mnemonic, derivationPath, index, language) +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCaller) DeriveKey0(opts *bind.CallOpts, mnemonic string, index uint32, language string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "deriveKey0", mnemonic, index, language) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey0(&_VmSafe.CallOpts, mnemonic, index, language) +} + +// DeriveKey0 is a free data retrieval call binding the contract method 0x32c8176d. +// +// Solidity: function deriveKey(string mnemonic, uint32 index, string language) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCallerSession) DeriveKey0(mnemonic string, index uint32, language string) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey0(&_VmSafe.CallOpts, mnemonic, index, language) +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCaller) DeriveKey1(opts *bind.CallOpts, mnemonic string, index uint32) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "deriveKey1", mnemonic, index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey1(&_VmSafe.CallOpts, mnemonic, index) +} + +// DeriveKey1 is a free data retrieval call binding the contract method 0x6229498b. +// +// Solidity: function deriveKey(string mnemonic, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCallerSession) DeriveKey1(mnemonic string, index uint32) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey1(&_VmSafe.CallOpts, mnemonic, index) +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCaller) DeriveKey2(opts *bind.CallOpts, mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "deriveKey2", mnemonic, derivationPath, index) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey2(&_VmSafe.CallOpts, mnemonic, derivationPath, index) +} + +// DeriveKey2 is a free data retrieval call binding the contract method 0x6bcb2c1b. +// +// Solidity: function deriveKey(string mnemonic, string derivationPath, uint32 index) pure returns(uint256 privateKey) +func (_VmSafe *VmSafeCallerSession) DeriveKey2(mnemonic string, derivationPath string, index uint32) (*big.Int, error) { + return _VmSafe.Contract.DeriveKey2(&_VmSafe.CallOpts, mnemonic, derivationPath, index) +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_VmSafe *VmSafeCaller) EnsNamehash(opts *bind.CallOpts, name string) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "ensNamehash", name) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_VmSafe *VmSafeSession) EnsNamehash(name string) ([32]byte, error) { + return _VmSafe.Contract.EnsNamehash(&_VmSafe.CallOpts, name) +} + +// EnsNamehash is a free data retrieval call binding the contract method 0x8c374c65. +// +// Solidity: function ensNamehash(string name) pure returns(bytes32) +func (_VmSafe *VmSafeCallerSession) EnsNamehash(name string) ([32]byte, error) { + return _VmSafe.Contract.EnsNamehash(&_VmSafe.CallOpts, name) +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_VmSafe *VmSafeCaller) EnvAddress(opts *bind.CallOpts, name string) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envAddress", name) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_VmSafe *VmSafeSession) EnvAddress(name string) (common.Address, error) { + return _VmSafe.Contract.EnvAddress(&_VmSafe.CallOpts, name) +} + +// EnvAddress is a free data retrieval call binding the contract method 0x350d56bf. +// +// Solidity: function envAddress(string name) view returns(address value) +func (_VmSafe *VmSafeCallerSession) EnvAddress(name string) (common.Address, error) { + return _VmSafe.Contract.EnvAddress(&_VmSafe.CallOpts, name) +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_VmSafe *VmSafeCaller) EnvAddress0(opts *bind.CallOpts, name string, delim string) ([]common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envAddress0", name, delim) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_VmSafe *VmSafeSession) EnvAddress0(name string, delim string) ([]common.Address, error) { + return _VmSafe.Contract.EnvAddress0(&_VmSafe.CallOpts, name, delim) +} + +// EnvAddress0 is a free data retrieval call binding the contract method 0xad31b9fa. +// +// Solidity: function envAddress(string name, string delim) view returns(address[] value) +func (_VmSafe *VmSafeCallerSession) EnvAddress0(name string, delim string) ([]common.Address, error) { + return _VmSafe.Contract.EnvAddress0(&_VmSafe.CallOpts, name, delim) +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_VmSafe *VmSafeCaller) EnvBool(opts *bind.CallOpts, name string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBool", name) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_VmSafe *VmSafeSession) EnvBool(name string) (bool, error) { + return _VmSafe.Contract.EnvBool(&_VmSafe.CallOpts, name) +} + +// EnvBool is a free data retrieval call binding the contract method 0x7ed1ec7d. +// +// Solidity: function envBool(string name) view returns(bool value) +func (_VmSafe *VmSafeCallerSession) EnvBool(name string) (bool, error) { + return _VmSafe.Contract.EnvBool(&_VmSafe.CallOpts, name) +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_VmSafe *VmSafeCaller) EnvBool0(opts *bind.CallOpts, name string, delim string) ([]bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBool0", name, delim) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_VmSafe *VmSafeSession) EnvBool0(name string, delim string) ([]bool, error) { + return _VmSafe.Contract.EnvBool0(&_VmSafe.CallOpts, name, delim) +} + +// EnvBool0 is a free data retrieval call binding the contract method 0xaaaddeaf. +// +// Solidity: function envBool(string name, string delim) view returns(bool[] value) +func (_VmSafe *VmSafeCallerSession) EnvBool0(name string, delim string) ([]bool, error) { + return _VmSafe.Contract.EnvBool0(&_VmSafe.CallOpts, name, delim) +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_VmSafe *VmSafeCaller) EnvBytes(opts *bind.CallOpts, name string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBytes", name) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_VmSafe *VmSafeSession) EnvBytes(name string) ([]byte, error) { + return _VmSafe.Contract.EnvBytes(&_VmSafe.CallOpts, name) +} + +// EnvBytes is a free data retrieval call binding the contract method 0x4d7baf06. +// +// Solidity: function envBytes(string name) view returns(bytes value) +func (_VmSafe *VmSafeCallerSession) EnvBytes(name string) ([]byte, error) { + return _VmSafe.Contract.EnvBytes(&_VmSafe.CallOpts, name) +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_VmSafe *VmSafeCaller) EnvBytes0(opts *bind.CallOpts, name string, delim string) ([][]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBytes0", name, delim) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_VmSafe *VmSafeSession) EnvBytes0(name string, delim string) ([][]byte, error) { + return _VmSafe.Contract.EnvBytes0(&_VmSafe.CallOpts, name, delim) +} + +// EnvBytes0 is a free data retrieval call binding the contract method 0xddc2651b. +// +// Solidity: function envBytes(string name, string delim) view returns(bytes[] value) +func (_VmSafe *VmSafeCallerSession) EnvBytes0(name string, delim string) ([][]byte, error) { + return _VmSafe.Contract.EnvBytes0(&_VmSafe.CallOpts, name, delim) +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_VmSafe *VmSafeCaller) EnvBytes32(opts *bind.CallOpts, name string, delim string) ([][32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBytes32", name, delim) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_VmSafe *VmSafeSession) EnvBytes32(name string, delim string) ([][32]byte, error) { + return _VmSafe.Contract.EnvBytes32(&_VmSafe.CallOpts, name, delim) +} + +// EnvBytes32 is a free data retrieval call binding the contract method 0x5af231c1. +// +// Solidity: function envBytes32(string name, string delim) view returns(bytes32[] value) +func (_VmSafe *VmSafeCallerSession) EnvBytes32(name string, delim string) ([][32]byte, error) { + return _VmSafe.Contract.EnvBytes32(&_VmSafe.CallOpts, name, delim) +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_VmSafe *VmSafeCaller) EnvBytes320(opts *bind.CallOpts, name string) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envBytes320", name) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_VmSafe *VmSafeSession) EnvBytes320(name string) ([32]byte, error) { + return _VmSafe.Contract.EnvBytes320(&_VmSafe.CallOpts, name) +} + +// EnvBytes320 is a free data retrieval call binding the contract method 0x97949042. +// +// Solidity: function envBytes32(string name) view returns(bytes32 value) +func (_VmSafe *VmSafeCallerSession) EnvBytes320(name string) ([32]byte, error) { + return _VmSafe.Contract.EnvBytes320(&_VmSafe.CallOpts, name) +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_VmSafe *VmSafeCaller) EnvExists(opts *bind.CallOpts, name string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envExists", name) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_VmSafe *VmSafeSession) EnvExists(name string) (bool, error) { + return _VmSafe.Contract.EnvExists(&_VmSafe.CallOpts, name) +} + +// EnvExists is a free data retrieval call binding the contract method 0xce8365f9. +// +// Solidity: function envExists(string name) view returns(bool result) +func (_VmSafe *VmSafeCallerSession) EnvExists(name string) (bool, error) { + return _VmSafe.Contract.EnvExists(&_VmSafe.CallOpts, name) +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_VmSafe *VmSafeCaller) EnvInt(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envInt", name, delim) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_VmSafe *VmSafeSession) EnvInt(name string, delim string) ([]*big.Int, error) { + return _VmSafe.Contract.EnvInt(&_VmSafe.CallOpts, name, delim) +} + +// EnvInt is a free data retrieval call binding the contract method 0x42181150. +// +// Solidity: function envInt(string name, string delim) view returns(int256[] value) +func (_VmSafe *VmSafeCallerSession) EnvInt(name string, delim string) ([]*big.Int, error) { + return _VmSafe.Contract.EnvInt(&_VmSafe.CallOpts, name, delim) +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_VmSafe *VmSafeCaller) EnvInt0(opts *bind.CallOpts, name string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envInt0", name) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_VmSafe *VmSafeSession) EnvInt0(name string) (*big.Int, error) { + return _VmSafe.Contract.EnvInt0(&_VmSafe.CallOpts, name) +} + +// EnvInt0 is a free data retrieval call binding the contract method 0x892a0c61. +// +// Solidity: function envInt(string name) view returns(int256 value) +func (_VmSafe *VmSafeCallerSession) EnvInt0(name string) (*big.Int, error) { + return _VmSafe.Contract.EnvInt0(&_VmSafe.CallOpts, name) +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_VmSafe *VmSafeCaller) EnvOr(opts *bind.CallOpts, name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr", name, delim, defaultValue) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_VmSafe *VmSafeSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + return _VmSafe.Contract.EnvOr(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr is a free data retrieval call binding the contract method 0x2281f367. +// +// Solidity: function envOr(string name, string delim, bytes32[] defaultValue) view returns(bytes32[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr(name string, delim string, defaultValue [][32]byte) ([][32]byte, error) { + return _VmSafe.Contract.EnvOr(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_VmSafe *VmSafeCaller) EnvOr0(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr0", name, delim, defaultValue) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_VmSafe *VmSafeSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _VmSafe.Contract.EnvOr0(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr0 is a free data retrieval call binding the contract method 0x4700d74b. +// +// Solidity: function envOr(string name, string delim, int256[] defaultValue) view returns(int256[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr0(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _VmSafe.Contract.EnvOr0(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_VmSafe *VmSafeCaller) EnvOr1(opts *bind.CallOpts, name string, defaultValue bool) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr1", name, defaultValue) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_VmSafe *VmSafeSession) EnvOr1(name string, defaultValue bool) (bool, error) { + return _VmSafe.Contract.EnvOr1(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr1 is a free data retrieval call binding the contract method 0x4777f3cf. +// +// Solidity: function envOr(string name, bool defaultValue) view returns(bool value) +func (_VmSafe *VmSafeCallerSession) EnvOr1(name string, defaultValue bool) (bool, error) { + return _VmSafe.Contract.EnvOr1(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_VmSafe *VmSafeCaller) EnvOr10(opts *bind.CallOpts, name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr10", name, delim, defaultValue) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_VmSafe *VmSafeSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + return _VmSafe.Contract.EnvOr10(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr10 is a free data retrieval call binding the contract method 0xc74e9deb. +// +// Solidity: function envOr(string name, string delim, address[] defaultValue) view returns(address[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr10(name string, delim string, defaultValue []common.Address) ([]common.Address, error) { + return _VmSafe.Contract.EnvOr10(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_VmSafe *VmSafeCaller) EnvOr11(opts *bind.CallOpts, name string, defaultValue string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr11", name, defaultValue) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_VmSafe *VmSafeSession) EnvOr11(name string, defaultValue string) (string, error) { + return _VmSafe.Contract.EnvOr11(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr11 is a free data retrieval call binding the contract method 0xd145736c. +// +// Solidity: function envOr(string name, string defaultValue) view returns(string value) +func (_VmSafe *VmSafeCallerSession) EnvOr11(name string, defaultValue string) (string, error) { + return _VmSafe.Contract.EnvOr11(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_VmSafe *VmSafeCaller) EnvOr12(opts *bind.CallOpts, name string, delim string, defaultValue []bool) ([]bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr12", name, delim, defaultValue) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_VmSafe *VmSafeSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) { + return _VmSafe.Contract.EnvOr12(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr12 is a free data retrieval call binding the contract method 0xeb85e83b. +// +// Solidity: function envOr(string name, string delim, bool[] defaultValue) view returns(bool[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr12(name string, delim string, defaultValue []bool) ([]bool, error) { + return _VmSafe.Contract.EnvOr12(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_VmSafe *VmSafeCaller) EnvOr2(opts *bind.CallOpts, name string, defaultValue common.Address) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr2", name, defaultValue) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_VmSafe *VmSafeSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) { + return _VmSafe.Contract.EnvOr2(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr2 is a free data retrieval call binding the contract method 0x561fe540. +// +// Solidity: function envOr(string name, address defaultValue) view returns(address value) +func (_VmSafe *VmSafeCallerSession) EnvOr2(name string, defaultValue common.Address) (common.Address, error) { + return _VmSafe.Contract.EnvOr2(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_VmSafe *VmSafeCaller) EnvOr3(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr3", name, defaultValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_VmSafe *VmSafeSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) { + return _VmSafe.Contract.EnvOr3(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr3 is a free data retrieval call binding the contract method 0x5e97348f. +// +// Solidity: function envOr(string name, uint256 defaultValue) view returns(uint256 value) +func (_VmSafe *VmSafeCallerSession) EnvOr3(name string, defaultValue *big.Int) (*big.Int, error) { + return _VmSafe.Contract.EnvOr3(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_VmSafe *VmSafeCaller) EnvOr4(opts *bind.CallOpts, name string, delim string, defaultValue [][]byte) ([][]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr4", name, delim, defaultValue) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_VmSafe *VmSafeSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) { + return _VmSafe.Contract.EnvOr4(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr4 is a free data retrieval call binding the contract method 0x64bc3e64. +// +// Solidity: function envOr(string name, string delim, bytes[] defaultValue) view returns(bytes[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr4(name string, delim string, defaultValue [][]byte) ([][]byte, error) { + return _VmSafe.Contract.EnvOr4(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_VmSafe *VmSafeCaller) EnvOr5(opts *bind.CallOpts, name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr5", name, delim, defaultValue) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_VmSafe *VmSafeSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _VmSafe.Contract.EnvOr5(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr5 is a free data retrieval call binding the contract method 0x74318528. +// +// Solidity: function envOr(string name, string delim, uint256[] defaultValue) view returns(uint256[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr5(name string, delim string, defaultValue []*big.Int) ([]*big.Int, error) { + return _VmSafe.Contract.EnvOr5(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_VmSafe *VmSafeCaller) EnvOr6(opts *bind.CallOpts, name string, delim string, defaultValue []string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr6", name, delim, defaultValue) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_VmSafe *VmSafeSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) { + return _VmSafe.Contract.EnvOr6(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr6 is a free data retrieval call binding the contract method 0x859216bc. +// +// Solidity: function envOr(string name, string delim, string[] defaultValue) view returns(string[] value) +func (_VmSafe *VmSafeCallerSession) EnvOr6(name string, delim string, defaultValue []string) ([]string, error) { + return _VmSafe.Contract.EnvOr6(&_VmSafe.CallOpts, name, delim, defaultValue) +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_VmSafe *VmSafeCaller) EnvOr7(opts *bind.CallOpts, name string, defaultValue []byte) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr7", name, defaultValue) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_VmSafe *VmSafeSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) { + return _VmSafe.Contract.EnvOr7(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr7 is a free data retrieval call binding the contract method 0xb3e47705. +// +// Solidity: function envOr(string name, bytes defaultValue) view returns(bytes value) +func (_VmSafe *VmSafeCallerSession) EnvOr7(name string, defaultValue []byte) ([]byte, error) { + return _VmSafe.Contract.EnvOr7(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_VmSafe *VmSafeCaller) EnvOr8(opts *bind.CallOpts, name string, defaultValue [32]byte) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr8", name, defaultValue) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_VmSafe *VmSafeSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) { + return _VmSafe.Contract.EnvOr8(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr8 is a free data retrieval call binding the contract method 0xb4a85892. +// +// Solidity: function envOr(string name, bytes32 defaultValue) view returns(bytes32 value) +func (_VmSafe *VmSafeCallerSession) EnvOr8(name string, defaultValue [32]byte) ([32]byte, error) { + return _VmSafe.Contract.EnvOr8(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_VmSafe *VmSafeCaller) EnvOr9(opts *bind.CallOpts, name string, defaultValue *big.Int) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envOr9", name, defaultValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_VmSafe *VmSafeSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) { + return _VmSafe.Contract.EnvOr9(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvOr9 is a free data retrieval call binding the contract method 0xbbcb713e. +// +// Solidity: function envOr(string name, int256 defaultValue) view returns(int256 value) +func (_VmSafe *VmSafeCallerSession) EnvOr9(name string, defaultValue *big.Int) (*big.Int, error) { + return _VmSafe.Contract.EnvOr9(&_VmSafe.CallOpts, name, defaultValue) +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_VmSafe *VmSafeCaller) EnvString(opts *bind.CallOpts, name string, delim string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envString", name, delim) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_VmSafe *VmSafeSession) EnvString(name string, delim string) ([]string, error) { + return _VmSafe.Contract.EnvString(&_VmSafe.CallOpts, name, delim) +} + +// EnvString is a free data retrieval call binding the contract method 0x14b02bc9. +// +// Solidity: function envString(string name, string delim) view returns(string[] value) +func (_VmSafe *VmSafeCallerSession) EnvString(name string, delim string) ([]string, error) { + return _VmSafe.Contract.EnvString(&_VmSafe.CallOpts, name, delim) +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_VmSafe *VmSafeCaller) EnvString0(opts *bind.CallOpts, name string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envString0", name) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_VmSafe *VmSafeSession) EnvString0(name string) (string, error) { + return _VmSafe.Contract.EnvString0(&_VmSafe.CallOpts, name) +} + +// EnvString0 is a free data retrieval call binding the contract method 0xf877cb19. +// +// Solidity: function envString(string name) view returns(string value) +func (_VmSafe *VmSafeCallerSession) EnvString0(name string) (string, error) { + return _VmSafe.Contract.EnvString0(&_VmSafe.CallOpts, name) +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_VmSafe *VmSafeCaller) EnvUint(opts *bind.CallOpts, name string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envUint", name) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_VmSafe *VmSafeSession) EnvUint(name string) (*big.Int, error) { + return _VmSafe.Contract.EnvUint(&_VmSafe.CallOpts, name) +} + +// EnvUint is a free data retrieval call binding the contract method 0xc1978d1f. +// +// Solidity: function envUint(string name) view returns(uint256 value) +func (_VmSafe *VmSafeCallerSession) EnvUint(name string) (*big.Int, error) { + return _VmSafe.Contract.EnvUint(&_VmSafe.CallOpts, name) +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_VmSafe *VmSafeCaller) EnvUint0(opts *bind.CallOpts, name string, delim string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "envUint0", name, delim) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_VmSafe *VmSafeSession) EnvUint0(name string, delim string) ([]*big.Int, error) { + return _VmSafe.Contract.EnvUint0(&_VmSafe.CallOpts, name, delim) +} + +// EnvUint0 is a free data retrieval call binding the contract method 0xf3dec099. +// +// Solidity: function envUint(string name, string delim) view returns(uint256[] value) +func (_VmSafe *VmSafeCallerSession) EnvUint0(name string, delim string) ([]*big.Int, error) { + return _VmSafe.Contract.EnvUint0(&_VmSafe.CallOpts, name, delim) +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_VmSafe *VmSafeCaller) FsMetadata(opts *bind.CallOpts, path string) (VmSafeFsMetadata, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "fsMetadata", path) + + if err != nil { + return *new(VmSafeFsMetadata), err + } + + out0 := *abi.ConvertType(out[0], new(VmSafeFsMetadata)).(*VmSafeFsMetadata) + + return out0, err + +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_VmSafe *VmSafeSession) FsMetadata(path string) (VmSafeFsMetadata, error) { + return _VmSafe.Contract.FsMetadata(&_VmSafe.CallOpts, path) +} + +// FsMetadata is a free data retrieval call binding the contract method 0xaf368a08. +// +// Solidity: function fsMetadata(string path) view returns((bool,bool,uint256,bool,uint256,uint256,uint256) metadata) +func (_VmSafe *VmSafeCallerSession) FsMetadata(path string) (VmSafeFsMetadata, error) { + return _VmSafe.Contract.FsMetadata(&_VmSafe.CallOpts, path) +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_VmSafe *VmSafeCaller) GetBlobBaseFee(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getBlobBaseFee") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_VmSafe *VmSafeSession) GetBlobBaseFee() (*big.Int, error) { + return _VmSafe.Contract.GetBlobBaseFee(&_VmSafe.CallOpts) +} + +// GetBlobBaseFee is a free data retrieval call binding the contract method 0x1f6d6ef7. +// +// Solidity: function getBlobBaseFee() view returns(uint256 blobBaseFee) +func (_VmSafe *VmSafeCallerSession) GetBlobBaseFee() (*big.Int, error) { + return _VmSafe.Contract.GetBlobBaseFee(&_VmSafe.CallOpts) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_VmSafe *VmSafeCaller) GetBlockNumber(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getBlockNumber") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_VmSafe *VmSafeSession) GetBlockNumber() (*big.Int, error) { + return _VmSafe.Contract.GetBlockNumber(&_VmSafe.CallOpts) +} + +// GetBlockNumber is a free data retrieval call binding the contract method 0x42cbb15c. +// +// Solidity: function getBlockNumber() view returns(uint256 height) +func (_VmSafe *VmSafeCallerSession) GetBlockNumber() (*big.Int, error) { + return _VmSafe.Contract.GetBlockNumber(&_VmSafe.CallOpts) +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_VmSafe *VmSafeCaller) GetBlockTimestamp(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getBlockTimestamp") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_VmSafe *VmSafeSession) GetBlockTimestamp() (*big.Int, error) { + return _VmSafe.Contract.GetBlockTimestamp(&_VmSafe.CallOpts) +} + +// GetBlockTimestamp is a free data retrieval call binding the contract method 0x796b89b9. +// +// Solidity: function getBlockTimestamp() view returns(uint256 timestamp) +func (_VmSafe *VmSafeCallerSession) GetBlockTimestamp() (*big.Int, error) { + return _VmSafe.Contract.GetBlockTimestamp(&_VmSafe.CallOpts) +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_VmSafe *VmSafeCaller) GetCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getCode", artifactPath) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_VmSafe *VmSafeSession) GetCode(artifactPath string) ([]byte, error) { + return _VmSafe.Contract.GetCode(&_VmSafe.CallOpts, artifactPath) +} + +// GetCode is a free data retrieval call binding the contract method 0x8d1cc925. +// +// Solidity: function getCode(string artifactPath) view returns(bytes creationBytecode) +func (_VmSafe *VmSafeCallerSession) GetCode(artifactPath string) ([]byte, error) { + return _VmSafe.Contract.GetCode(&_VmSafe.CallOpts, artifactPath) +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_VmSafe *VmSafeCaller) GetDeployedCode(opts *bind.CallOpts, artifactPath string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getDeployedCode", artifactPath) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_VmSafe *VmSafeSession) GetDeployedCode(artifactPath string) ([]byte, error) { + return _VmSafe.Contract.GetDeployedCode(&_VmSafe.CallOpts, artifactPath) +} + +// GetDeployedCode is a free data retrieval call binding the contract method 0x3ebf73b4. +// +// Solidity: function getDeployedCode(string artifactPath) view returns(bytes runtimeBytecode) +func (_VmSafe *VmSafeCallerSession) GetDeployedCode(artifactPath string) ([]byte, error) { + return _VmSafe.Contract.GetDeployedCode(&_VmSafe.CallOpts, artifactPath) +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_VmSafe *VmSafeCaller) GetLabel(opts *bind.CallOpts, account common.Address) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getLabel", account) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_VmSafe *VmSafeSession) GetLabel(account common.Address) (string, error) { + return _VmSafe.Contract.GetLabel(&_VmSafe.CallOpts, account) +} + +// GetLabel is a free data retrieval call binding the contract method 0x28a249b0. +// +// Solidity: function getLabel(address account) view returns(string currentLabel) +func (_VmSafe *VmSafeCallerSession) GetLabel(account common.Address) (string, error) { + return _VmSafe.Contract.GetLabel(&_VmSafe.CallOpts, account) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_VmSafe *VmSafeCaller) GetNonce(opts *bind.CallOpts, account common.Address) (uint64, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "getNonce", account) + + if err != nil { + return *new(uint64), err + } + + out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64) + + return out0, err + +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_VmSafe *VmSafeSession) GetNonce(account common.Address) (uint64, error) { + return _VmSafe.Contract.GetNonce(&_VmSafe.CallOpts, account) +} + +// GetNonce is a free data retrieval call binding the contract method 0x2d0335ab. +// +// Solidity: function getNonce(address account) view returns(uint64 nonce) +func (_VmSafe *VmSafeCallerSession) GetNonce(account common.Address) (uint64, error) { + return _VmSafe.Contract.GetNonce(&_VmSafe.CallOpts, account) +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_VmSafe *VmSafeCaller) IndexOf(opts *bind.CallOpts, input string, key string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "indexOf", input, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_VmSafe *VmSafeSession) IndexOf(input string, key string) (*big.Int, error) { + return _VmSafe.Contract.IndexOf(&_VmSafe.CallOpts, input, key) +} + +// IndexOf is a free data retrieval call binding the contract method 0x8a0807b7. +// +// Solidity: function indexOf(string input, string key) pure returns(uint256) +func (_VmSafe *VmSafeCallerSession) IndexOf(input string, key string) (*big.Int, error) { + return _VmSafe.Contract.IndexOf(&_VmSafe.CallOpts, input, key) +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_VmSafe *VmSafeCaller) IsContext(opts *bind.CallOpts, context uint8) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "isContext", context) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_VmSafe *VmSafeSession) IsContext(context uint8) (bool, error) { + return _VmSafe.Contract.IsContext(&_VmSafe.CallOpts, context) +} + +// IsContext is a free data retrieval call binding the contract method 0x64af255d. +// +// Solidity: function isContext(uint8 context) view returns(bool result) +func (_VmSafe *VmSafeCallerSession) IsContext(context uint8) (bool, error) { + return _VmSafe.Contract.IsContext(&_VmSafe.CallOpts, context) +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_VmSafe *VmSafeCaller) KeyExists(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "keyExists", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_VmSafe *VmSafeSession) KeyExists(json string, key string) (bool, error) { + return _VmSafe.Contract.KeyExists(&_VmSafe.CallOpts, json, key) +} + +// KeyExists is a free data retrieval call binding the contract method 0x528a683c. +// +// Solidity: function keyExists(string json, string key) view returns(bool) +func (_VmSafe *VmSafeCallerSession) KeyExists(json string, key string) (bool, error) { + return _VmSafe.Contract.KeyExists(&_VmSafe.CallOpts, json, key) +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_VmSafe *VmSafeCaller) KeyExistsJson(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "keyExistsJson", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_VmSafe *VmSafeSession) KeyExistsJson(json string, key string) (bool, error) { + return _VmSafe.Contract.KeyExistsJson(&_VmSafe.CallOpts, json, key) +} + +// KeyExistsJson is a free data retrieval call binding the contract method 0xdb4235f6. +// +// Solidity: function keyExistsJson(string json, string key) view returns(bool) +func (_VmSafe *VmSafeCallerSession) KeyExistsJson(json string, key string) (bool, error) { + return _VmSafe.Contract.KeyExistsJson(&_VmSafe.CallOpts, json, key) +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_VmSafe *VmSafeCaller) KeyExistsToml(opts *bind.CallOpts, toml string, key string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "keyExistsToml", toml, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_VmSafe *VmSafeSession) KeyExistsToml(toml string, key string) (bool, error) { + return _VmSafe.Contract.KeyExistsToml(&_VmSafe.CallOpts, toml, key) +} + +// KeyExistsToml is a free data retrieval call binding the contract method 0x600903ad. +// +// Solidity: function keyExistsToml(string toml, string key) view returns(bool) +func (_VmSafe *VmSafeCallerSession) KeyExistsToml(toml string, key string) (bool, error) { + return _VmSafe.Contract.KeyExistsToml(&_VmSafe.CallOpts, toml, key) +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_VmSafe *VmSafeCaller) LastCallGas(opts *bind.CallOpts) (VmSafeGas, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "lastCallGas") + + if err != nil { + return *new(VmSafeGas), err + } + + out0 := *abi.ConvertType(out[0], new(VmSafeGas)).(*VmSafeGas) + + return out0, err + +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_VmSafe *VmSafeSession) LastCallGas() (VmSafeGas, error) { + return _VmSafe.Contract.LastCallGas(&_VmSafe.CallOpts) +} + +// LastCallGas is a free data retrieval call binding the contract method 0x2b589b28. +// +// Solidity: function lastCallGas() view returns((uint64,uint64,uint64,int64,uint64) gas) +func (_VmSafe *VmSafeCallerSession) LastCallGas() (VmSafeGas, error) { + return _VmSafe.Contract.LastCallGas(&_VmSafe.CallOpts) +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_VmSafe *VmSafeCaller) Load(opts *bind.CallOpts, target common.Address, slot [32]byte) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "load", target, slot) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_VmSafe *VmSafeSession) Load(target common.Address, slot [32]byte) ([32]byte, error) { + return _VmSafe.Contract.Load(&_VmSafe.CallOpts, target, slot) +} + +// Load is a free data retrieval call binding the contract method 0x667f9d70. +// +// Solidity: function load(address target, bytes32 slot) view returns(bytes32 data) +func (_VmSafe *VmSafeCallerSession) Load(target common.Address, slot [32]byte) ([32]byte, error) { + return _VmSafe.Contract.Load(&_VmSafe.CallOpts, target, slot) +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_VmSafe *VmSafeCaller) ParseAddress(opts *bind.CallOpts, stringifiedValue string) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseAddress", stringifiedValue) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_VmSafe *VmSafeSession) ParseAddress(stringifiedValue string) (common.Address, error) { + return _VmSafe.Contract.ParseAddress(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseAddress is a free data retrieval call binding the contract method 0xc6ce059d. +// +// Solidity: function parseAddress(string stringifiedValue) pure returns(address parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseAddress(stringifiedValue string) (common.Address, error) { + return _VmSafe.Contract.ParseAddress(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_VmSafe *VmSafeCaller) ParseBool(opts *bind.CallOpts, stringifiedValue string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseBool", stringifiedValue) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_VmSafe *VmSafeSession) ParseBool(stringifiedValue string) (bool, error) { + return _VmSafe.Contract.ParseBool(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBool is a free data retrieval call binding the contract method 0x974ef924. +// +// Solidity: function parseBool(string stringifiedValue) pure returns(bool parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseBool(stringifiedValue string) (bool, error) { + return _VmSafe.Contract.ParseBool(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_VmSafe *VmSafeCaller) ParseBytes(opts *bind.CallOpts, stringifiedValue string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseBytes", stringifiedValue) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_VmSafe *VmSafeSession) ParseBytes(stringifiedValue string) ([]byte, error) { + return _VmSafe.Contract.ParseBytes(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBytes is a free data retrieval call binding the contract method 0x8f5d232d. +// +// Solidity: function parseBytes(string stringifiedValue) pure returns(bytes parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseBytes(stringifiedValue string) ([]byte, error) { + return _VmSafe.Contract.ParseBytes(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_VmSafe *VmSafeCaller) ParseBytes32(opts *bind.CallOpts, stringifiedValue string) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseBytes32", stringifiedValue) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_VmSafe *VmSafeSession) ParseBytes32(stringifiedValue string) ([32]byte, error) { + return _VmSafe.Contract.ParseBytes32(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseBytes32 is a free data retrieval call binding the contract method 0x087e6e81. +// +// Solidity: function parseBytes32(string stringifiedValue) pure returns(bytes32 parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseBytes32(stringifiedValue string) ([32]byte, error) { + return _VmSafe.Contract.ParseBytes32(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_VmSafe *VmSafeCaller) ParseInt(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseInt", stringifiedValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_VmSafe *VmSafeSession) ParseInt(stringifiedValue string) (*big.Int, error) { + return _VmSafe.Contract.ParseInt(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseInt is a free data retrieval call binding the contract method 0x42346c5e. +// +// Solidity: function parseInt(string stringifiedValue) pure returns(int256 parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseInt(stringifiedValue string) (*big.Int, error) { + return _VmSafe.Contract.ParseInt(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCaller) ParseJson(opts *bind.CallOpts, json string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJson", json) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeSession) ParseJson(json string) ([]byte, error) { + return _VmSafe.Contract.ParseJson(&_VmSafe.CallOpts, json) +} + +// ParseJson is a free data retrieval call binding the contract method 0x6a82600a. +// +// Solidity: function parseJson(string json) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCallerSession) ParseJson(json string) ([]byte, error) { + return _VmSafe.Contract.ParseJson(&_VmSafe.CallOpts, json) +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCaller) ParseJson0(opts *bind.CallOpts, json string, key string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJson0", json, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeSession) ParseJson0(json string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseJson0(&_VmSafe.CallOpts, json, key) +} + +// ParseJson0 is a free data retrieval call binding the contract method 0x85940ef1. +// +// Solidity: function parseJson(string json, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCallerSession) ParseJson0(json string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseJson0(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_VmSafe *VmSafeCaller) ParseJsonAddress(opts *bind.CallOpts, json string, key string) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonAddress", json, key) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_VmSafe *VmSafeSession) ParseJsonAddress(json string, key string) (common.Address, error) { + return _VmSafe.Contract.ParseJsonAddress(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonAddress is a free data retrieval call binding the contract method 0x1e19e657. +// +// Solidity: function parseJsonAddress(string json, string key) pure returns(address) +func (_VmSafe *VmSafeCallerSession) ParseJsonAddress(json string, key string) (common.Address, error) { + return _VmSafe.Contract.ParseJsonAddress(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_VmSafe *VmSafeCaller) ParseJsonAddressArray(opts *bind.CallOpts, json string, key string) ([]common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonAddressArray", json, key) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_VmSafe *VmSafeSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) { + return _VmSafe.Contract.ParseJsonAddressArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonAddressArray is a free data retrieval call binding the contract method 0x2fce7883. +// +// Solidity: function parseJsonAddressArray(string json, string key) pure returns(address[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonAddressArray(json string, key string) ([]common.Address, error) { + return _VmSafe.Contract.ParseJsonAddressArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_VmSafe *VmSafeCaller) ParseJsonBool(opts *bind.CallOpts, json string, key string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBool", json, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_VmSafe *VmSafeSession) ParseJsonBool(json string, key string) (bool, error) { + return _VmSafe.Contract.ParseJsonBool(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBool is a free data retrieval call binding the contract method 0x9f86dc91. +// +// Solidity: function parseJsonBool(string json, string key) pure returns(bool) +func (_VmSafe *VmSafeCallerSession) ParseJsonBool(json string, key string) (bool, error) { + return _VmSafe.Contract.ParseJsonBool(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_VmSafe *VmSafeCaller) ParseJsonBoolArray(opts *bind.CallOpts, json string, key string) ([]bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBoolArray", json, key) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_VmSafe *VmSafeSession) ParseJsonBoolArray(json string, key string) ([]bool, error) { + return _VmSafe.Contract.ParseJsonBoolArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBoolArray is a free data retrieval call binding the contract method 0x91f3b94f. +// +// Solidity: function parseJsonBoolArray(string json, string key) pure returns(bool[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonBoolArray(json string, key string) ([]bool, error) { + return _VmSafe.Contract.ParseJsonBoolArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_VmSafe *VmSafeCaller) ParseJsonBytes(opts *bind.CallOpts, json string, key string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes", json, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_VmSafe *VmSafeSession) ParseJsonBytes(json string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseJsonBytes(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes is a free data retrieval call binding the contract method 0xfd921be8. +// +// Solidity: function parseJsonBytes(string json, string key) pure returns(bytes) +func (_VmSafe *VmSafeCallerSession) ParseJsonBytes(json string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseJsonBytes(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_VmSafe *VmSafeCaller) ParseJsonBytes32(opts *bind.CallOpts, json string, key string) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes32", json, key) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_VmSafe *VmSafeSession) ParseJsonBytes32(json string, key string) ([32]byte, error) { + return _VmSafe.Contract.ParseJsonBytes32(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes32 is a free data retrieval call binding the contract method 0x1777e59d. +// +// Solidity: function parseJsonBytes32(string json, string key) pure returns(bytes32) +func (_VmSafe *VmSafeCallerSession) ParseJsonBytes32(json string, key string) ([32]byte, error) { + return _VmSafe.Contract.ParseJsonBytes32(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeCaller) ParseJsonBytes32Array(opts *bind.CallOpts, json string, key string) ([][32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBytes32Array", json, key) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) { + return _VmSafe.Contract.ParseJsonBytes32Array(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytes32Array is a free data retrieval call binding the contract method 0x91c75bc3. +// +// Solidity: function parseJsonBytes32Array(string json, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonBytes32Array(json string, key string) ([][32]byte, error) { + return _VmSafe.Contract.ParseJsonBytes32Array(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeCaller) ParseJsonBytesArray(opts *bind.CallOpts, json string, key string) ([][]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonBytesArray", json, key) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) { + return _VmSafe.Contract.ParseJsonBytesArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonBytesArray is a free data retrieval call binding the contract method 0x6631aa99. +// +// Solidity: function parseJsonBytesArray(string json, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonBytesArray(json string, key string) ([][]byte, error) { + return _VmSafe.Contract.ParseJsonBytesArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_VmSafe *VmSafeCaller) ParseJsonInt(opts *bind.CallOpts, json string, key string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonInt", json, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_VmSafe *VmSafeSession) ParseJsonInt(json string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseJsonInt(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonInt is a free data retrieval call binding the contract method 0x7b048ccd. +// +// Solidity: function parseJsonInt(string json, string key) pure returns(int256) +func (_VmSafe *VmSafeCallerSession) ParseJsonInt(json string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseJsonInt(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_VmSafe *VmSafeCaller) ParseJsonIntArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonIntArray", json, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_VmSafe *VmSafeSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseJsonIntArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonIntArray is a free data retrieval call binding the contract method 0x9983c28a. +// +// Solidity: function parseJsonIntArray(string json, string key) pure returns(int256[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonIntArray(json string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseJsonIntArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeCaller) ParseJsonKeys(opts *bind.CallOpts, json string, key string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonKeys", json, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeSession) ParseJsonKeys(json string, key string) ([]string, error) { + return _VmSafe.Contract.ParseJsonKeys(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonKeys is a free data retrieval call binding the contract method 0x213e4198. +// +// Solidity: function parseJsonKeys(string json, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeCallerSession) ParseJsonKeys(json string, key string) ([]string, error) { + return _VmSafe.Contract.ParseJsonKeys(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_VmSafe *VmSafeCaller) ParseJsonString(opts *bind.CallOpts, json string, key string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonString", json, key) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_VmSafe *VmSafeSession) ParseJsonString(json string, key string) (string, error) { + return _VmSafe.Contract.ParseJsonString(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonString is a free data retrieval call binding the contract method 0x49c4fac8. +// +// Solidity: function parseJsonString(string json, string key) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ParseJsonString(json string, key string) (string, error) { + return _VmSafe.Contract.ParseJsonString(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_VmSafe *VmSafeCaller) ParseJsonStringArray(opts *bind.CallOpts, json string, key string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonStringArray", json, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_VmSafe *VmSafeSession) ParseJsonStringArray(json string, key string) ([]string, error) { + return _VmSafe.Contract.ParseJsonStringArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonStringArray is a free data retrieval call binding the contract method 0x498fdcf4. +// +// Solidity: function parseJsonStringArray(string json, string key) pure returns(string[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonStringArray(json string, key string) ([]string, error) { + return _VmSafe.Contract.ParseJsonStringArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_VmSafe *VmSafeCaller) ParseJsonUint(opts *bind.CallOpts, json string, key string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonUint", json, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_VmSafe *VmSafeSession) ParseJsonUint(json string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseJsonUint(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonUint is a free data retrieval call binding the contract method 0xaddde2b6. +// +// Solidity: function parseJsonUint(string json, string key) pure returns(uint256) +func (_VmSafe *VmSafeCallerSession) ParseJsonUint(json string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseJsonUint(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeCaller) ParseJsonUintArray(opts *bind.CallOpts, json string, key string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseJsonUintArray", json, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseJsonUintArray(&_VmSafe.CallOpts, json, key) +} + +// ParseJsonUintArray is a free data retrieval call binding the contract method 0x522074ab. +// +// Solidity: function parseJsonUintArray(string json, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeCallerSession) ParseJsonUintArray(json string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseJsonUintArray(&_VmSafe.CallOpts, json, key) +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCaller) ParseToml(opts *bind.CallOpts, toml string, key string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseToml", toml, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeSession) ParseToml(toml string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseToml(&_VmSafe.CallOpts, toml, key) +} + +// ParseToml is a free data retrieval call binding the contract method 0x37736e08. +// +// Solidity: function parseToml(string toml, string key) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCallerSession) ParseToml(toml string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseToml(&_VmSafe.CallOpts, toml, key) +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCaller) ParseToml0(opts *bind.CallOpts, toml string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseToml0", toml) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeSession) ParseToml0(toml string) ([]byte, error) { + return _VmSafe.Contract.ParseToml0(&_VmSafe.CallOpts, toml) +} + +// ParseToml0 is a free data retrieval call binding the contract method 0x592151f0. +// +// Solidity: function parseToml(string toml) pure returns(bytes abiEncodedData) +func (_VmSafe *VmSafeCallerSession) ParseToml0(toml string) ([]byte, error) { + return _VmSafe.Contract.ParseToml0(&_VmSafe.CallOpts, toml) +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_VmSafe *VmSafeCaller) ParseTomlAddress(opts *bind.CallOpts, toml string, key string) (common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlAddress", toml, key) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_VmSafe *VmSafeSession) ParseTomlAddress(toml string, key string) (common.Address, error) { + return _VmSafe.Contract.ParseTomlAddress(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlAddress is a free data retrieval call binding the contract method 0x65e7c844. +// +// Solidity: function parseTomlAddress(string toml, string key) pure returns(address) +func (_VmSafe *VmSafeCallerSession) ParseTomlAddress(toml string, key string) (common.Address, error) { + return _VmSafe.Contract.ParseTomlAddress(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_VmSafe *VmSafeCaller) ParseTomlAddressArray(opts *bind.CallOpts, toml string, key string) ([]common.Address, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlAddressArray", toml, key) + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_VmSafe *VmSafeSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) { + return _VmSafe.Contract.ParseTomlAddressArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlAddressArray is a free data retrieval call binding the contract method 0x65c428e7. +// +// Solidity: function parseTomlAddressArray(string toml, string key) pure returns(address[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlAddressArray(toml string, key string) ([]common.Address, error) { + return _VmSafe.Contract.ParseTomlAddressArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_VmSafe *VmSafeCaller) ParseTomlBool(opts *bind.CallOpts, toml string, key string) (bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBool", toml, key) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_VmSafe *VmSafeSession) ParseTomlBool(toml string, key string) (bool, error) { + return _VmSafe.Contract.ParseTomlBool(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBool is a free data retrieval call binding the contract method 0xd30dced6. +// +// Solidity: function parseTomlBool(string toml, string key) pure returns(bool) +func (_VmSafe *VmSafeCallerSession) ParseTomlBool(toml string, key string) (bool, error) { + return _VmSafe.Contract.ParseTomlBool(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_VmSafe *VmSafeCaller) ParseTomlBoolArray(opts *bind.CallOpts, toml string, key string) ([]bool, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBoolArray", toml, key) + + if err != nil { + return *new([]bool), err + } + + out0 := *abi.ConvertType(out[0], new([]bool)).(*[]bool) + + return out0, err + +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_VmSafe *VmSafeSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) { + return _VmSafe.Contract.ParseTomlBoolArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBoolArray is a free data retrieval call binding the contract method 0x127cfe9a. +// +// Solidity: function parseTomlBoolArray(string toml, string key) pure returns(bool[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlBoolArray(toml string, key string) ([]bool, error) { + return _VmSafe.Contract.ParseTomlBoolArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_VmSafe *VmSafeCaller) ParseTomlBytes(opts *bind.CallOpts, toml string, key string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes", toml, key) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_VmSafe *VmSafeSession) ParseTomlBytes(toml string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseTomlBytes(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes is a free data retrieval call binding the contract method 0xd77bfdb9. +// +// Solidity: function parseTomlBytes(string toml, string key) pure returns(bytes) +func (_VmSafe *VmSafeCallerSession) ParseTomlBytes(toml string, key string) ([]byte, error) { + return _VmSafe.Contract.ParseTomlBytes(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_VmSafe *VmSafeCaller) ParseTomlBytes32(opts *bind.CallOpts, toml string, key string) ([32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes32", toml, key) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_VmSafe *VmSafeSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) { + return _VmSafe.Contract.ParseTomlBytes32(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes32 is a free data retrieval call binding the contract method 0x8e214810. +// +// Solidity: function parseTomlBytes32(string toml, string key) pure returns(bytes32) +func (_VmSafe *VmSafeCallerSession) ParseTomlBytes32(toml string, key string) ([32]byte, error) { + return _VmSafe.Contract.ParseTomlBytes32(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeCaller) ParseTomlBytes32Array(opts *bind.CallOpts, toml string, key string) ([][32]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBytes32Array", toml, key) + + if err != nil { + return *new([][32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][32]byte)).(*[][32]byte) + + return out0, err + +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) { + return _VmSafe.Contract.ParseTomlBytes32Array(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytes32Array is a free data retrieval call binding the contract method 0x3e716f81. +// +// Solidity: function parseTomlBytes32Array(string toml, string key) pure returns(bytes32[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlBytes32Array(toml string, key string) ([][32]byte, error) { + return _VmSafe.Contract.ParseTomlBytes32Array(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeCaller) ParseTomlBytesArray(opts *bind.CallOpts, toml string, key string) ([][]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlBytesArray", toml, key) + + if err != nil { + return *new([][]byte), err + } + + out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte) + + return out0, err + +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) { + return _VmSafe.Contract.ParseTomlBytesArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlBytesArray is a free data retrieval call binding the contract method 0xb197c247. +// +// Solidity: function parseTomlBytesArray(string toml, string key) pure returns(bytes[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlBytesArray(toml string, key string) ([][]byte, error) { + return _VmSafe.Contract.ParseTomlBytesArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_VmSafe *VmSafeCaller) ParseTomlInt(opts *bind.CallOpts, toml string, key string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlInt", toml, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_VmSafe *VmSafeSession) ParseTomlInt(toml string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseTomlInt(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlInt is a free data retrieval call binding the contract method 0xc1350739. +// +// Solidity: function parseTomlInt(string toml, string key) pure returns(int256) +func (_VmSafe *VmSafeCallerSession) ParseTomlInt(toml string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseTomlInt(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_VmSafe *VmSafeCaller) ParseTomlIntArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlIntArray", toml, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_VmSafe *VmSafeSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseTomlIntArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlIntArray is a free data retrieval call binding the contract method 0xd3522ae6. +// +// Solidity: function parseTomlIntArray(string toml, string key) pure returns(int256[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlIntArray(toml string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseTomlIntArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeCaller) ParseTomlKeys(opts *bind.CallOpts, toml string, key string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlKeys", toml, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeSession) ParseTomlKeys(toml string, key string) ([]string, error) { + return _VmSafe.Contract.ParseTomlKeys(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlKeys is a free data retrieval call binding the contract method 0x812a44b2. +// +// Solidity: function parseTomlKeys(string toml, string key) pure returns(string[] keys) +func (_VmSafe *VmSafeCallerSession) ParseTomlKeys(toml string, key string) ([]string, error) { + return _VmSafe.Contract.ParseTomlKeys(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_VmSafe *VmSafeCaller) ParseTomlString(opts *bind.CallOpts, toml string, key string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlString", toml, key) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_VmSafe *VmSafeSession) ParseTomlString(toml string, key string) (string, error) { + return _VmSafe.Contract.ParseTomlString(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlString is a free data retrieval call binding the contract method 0x8bb8dd43. +// +// Solidity: function parseTomlString(string toml, string key) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ParseTomlString(toml string, key string) (string, error) { + return _VmSafe.Contract.ParseTomlString(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_VmSafe *VmSafeCaller) ParseTomlStringArray(opts *bind.CallOpts, toml string, key string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlStringArray", toml, key) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_VmSafe *VmSafeSession) ParseTomlStringArray(toml string, key string) ([]string, error) { + return _VmSafe.Contract.ParseTomlStringArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlStringArray is a free data retrieval call binding the contract method 0x9f629281. +// +// Solidity: function parseTomlStringArray(string toml, string key) pure returns(string[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlStringArray(toml string, key string) ([]string, error) { + return _VmSafe.Contract.ParseTomlStringArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_VmSafe *VmSafeCaller) ParseTomlUint(opts *bind.CallOpts, toml string, key string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlUint", toml, key) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_VmSafe *VmSafeSession) ParseTomlUint(toml string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseTomlUint(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlUint is a free data retrieval call binding the contract method 0xcc7b0487. +// +// Solidity: function parseTomlUint(string toml, string key) pure returns(uint256) +func (_VmSafe *VmSafeCallerSession) ParseTomlUint(toml string, key string) (*big.Int, error) { + return _VmSafe.Contract.ParseTomlUint(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeCaller) ParseTomlUintArray(opts *bind.CallOpts, toml string, key string) ([]*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseTomlUintArray", toml, key) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseTomlUintArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseTomlUintArray is a free data retrieval call binding the contract method 0xb5df27c8. +// +// Solidity: function parseTomlUintArray(string toml, string key) pure returns(uint256[]) +func (_VmSafe *VmSafeCallerSession) ParseTomlUintArray(toml string, key string) ([]*big.Int, error) { + return _VmSafe.Contract.ParseTomlUintArray(&_VmSafe.CallOpts, toml, key) +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_VmSafe *VmSafeCaller) ParseUint(opts *bind.CallOpts, stringifiedValue string) (*big.Int, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "parseUint", stringifiedValue) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_VmSafe *VmSafeSession) ParseUint(stringifiedValue string) (*big.Int, error) { + return _VmSafe.Contract.ParseUint(&_VmSafe.CallOpts, stringifiedValue) +} + +// ParseUint is a free data retrieval call binding the contract method 0xfa91454d. +// +// Solidity: function parseUint(string stringifiedValue) pure returns(uint256 parsedValue) +func (_VmSafe *VmSafeCallerSession) ParseUint(stringifiedValue string) (*big.Int, error) { + return _VmSafe.Contract.ParseUint(&_VmSafe.CallOpts, stringifiedValue) +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_VmSafe *VmSafeCaller) ProjectRoot(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "projectRoot") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_VmSafe *VmSafeSession) ProjectRoot() (string, error) { + return _VmSafe.Contract.ProjectRoot(&_VmSafe.CallOpts) +} + +// ProjectRoot is a free data retrieval call binding the contract method 0xd930a0e6. +// +// Solidity: function projectRoot() view returns(string path) +func (_VmSafe *VmSafeCallerSession) ProjectRoot() (string, error) { + return _VmSafe.Contract.ProjectRoot(&_VmSafe.CallOpts) +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCaller) ReadDir(opts *bind.CallOpts, path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readDir", path, maxDepth) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir(&_VmSafe.CallOpts, path, maxDepth) +} + +// ReadDir is a free data retrieval call binding the contract method 0x1497876c. +// +// Solidity: function readDir(string path, uint64 maxDepth) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCallerSession) ReadDir(path string, maxDepth uint64) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir(&_VmSafe.CallOpts, path, maxDepth) +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCaller) ReadDir0(opts *bind.CallOpts, path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readDir0", path, maxDepth, followLinks) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir0(&_VmSafe.CallOpts, path, maxDepth, followLinks) +} + +// ReadDir0 is a free data retrieval call binding the contract method 0x8102d70d. +// +// Solidity: function readDir(string path, uint64 maxDepth, bool followLinks) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCallerSession) ReadDir0(path string, maxDepth uint64, followLinks bool) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir0(&_VmSafe.CallOpts, path, maxDepth, followLinks) +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCaller) ReadDir1(opts *bind.CallOpts, path string) ([]VmSafeDirEntry, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readDir1", path) + + if err != nil { + return *new([]VmSafeDirEntry), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeDirEntry)).(*[]VmSafeDirEntry) + + return out0, err + +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeSession) ReadDir1(path string) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir1(&_VmSafe.CallOpts, path) +} + +// ReadDir1 is a free data retrieval call binding the contract method 0xc4bc59e0. +// +// Solidity: function readDir(string path) view returns((string,string,uint64,bool,bool)[] entries) +func (_VmSafe *VmSafeCallerSession) ReadDir1(path string) ([]VmSafeDirEntry, error) { + return _VmSafe.Contract.ReadDir1(&_VmSafe.CallOpts, path) +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_VmSafe *VmSafeCaller) ReadFile(opts *bind.CallOpts, path string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readFile", path) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_VmSafe *VmSafeSession) ReadFile(path string) (string, error) { + return _VmSafe.Contract.ReadFile(&_VmSafe.CallOpts, path) +} + +// ReadFile is a free data retrieval call binding the contract method 0x60f9bb11. +// +// Solidity: function readFile(string path) view returns(string data) +func (_VmSafe *VmSafeCallerSession) ReadFile(path string) (string, error) { + return _VmSafe.Contract.ReadFile(&_VmSafe.CallOpts, path) +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_VmSafe *VmSafeCaller) ReadFileBinary(opts *bind.CallOpts, path string) ([]byte, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readFileBinary", path) + + if err != nil { + return *new([]byte), err + } + + out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte) + + return out0, err + +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_VmSafe *VmSafeSession) ReadFileBinary(path string) ([]byte, error) { + return _VmSafe.Contract.ReadFileBinary(&_VmSafe.CallOpts, path) +} + +// ReadFileBinary is a free data retrieval call binding the contract method 0x16ed7bc4. +// +// Solidity: function readFileBinary(string path) view returns(bytes data) +func (_VmSafe *VmSafeCallerSession) ReadFileBinary(path string) ([]byte, error) { + return _VmSafe.Contract.ReadFileBinary(&_VmSafe.CallOpts, path) +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_VmSafe *VmSafeCaller) ReadLine(opts *bind.CallOpts, path string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readLine", path) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_VmSafe *VmSafeSession) ReadLine(path string) (string, error) { + return _VmSafe.Contract.ReadLine(&_VmSafe.CallOpts, path) +} + +// ReadLine is a free data retrieval call binding the contract method 0x70f55728. +// +// Solidity: function readLine(string path) view returns(string line) +func (_VmSafe *VmSafeCallerSession) ReadLine(path string) (string, error) { + return _VmSafe.Contract.ReadLine(&_VmSafe.CallOpts, path) +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_VmSafe *VmSafeCaller) ReadLink(opts *bind.CallOpts, linkPath string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "readLink", linkPath) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_VmSafe *VmSafeSession) ReadLink(linkPath string) (string, error) { + return _VmSafe.Contract.ReadLink(&_VmSafe.CallOpts, linkPath) +} + +// ReadLink is a free data retrieval call binding the contract method 0x9f5684a2. +// +// Solidity: function readLink(string linkPath) view returns(string targetPath) +func (_VmSafe *VmSafeCallerSession) ReadLink(linkPath string) (string, error) { + return _VmSafe.Contract.ReadLink(&_VmSafe.CallOpts, linkPath) +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_VmSafe *VmSafeCaller) Replace(opts *bind.CallOpts, input string, from string, to string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "replace", input, from, to) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_VmSafe *VmSafeSession) Replace(input string, from string, to string) (string, error) { + return _VmSafe.Contract.Replace(&_VmSafe.CallOpts, input, from, to) +} + +// Replace is a free data retrieval call binding the contract method 0xe00ad03e. +// +// Solidity: function replace(string input, string from, string to) pure returns(string output) +func (_VmSafe *VmSafeCallerSession) Replace(input string, from string, to string) (string, error) { + return _VmSafe.Contract.Replace(&_VmSafe.CallOpts, input, from, to) +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_VmSafe *VmSafeCaller) RpcUrl(opts *bind.CallOpts, rpcAlias string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "rpcUrl", rpcAlias) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_VmSafe *VmSafeSession) RpcUrl(rpcAlias string) (string, error) { + return _VmSafe.Contract.RpcUrl(&_VmSafe.CallOpts, rpcAlias) +} + +// RpcUrl is a free data retrieval call binding the contract method 0x975a6ce9. +// +// Solidity: function rpcUrl(string rpcAlias) view returns(string json) +func (_VmSafe *VmSafeCallerSession) RpcUrl(rpcAlias string) (string, error) { + return _VmSafe.Contract.RpcUrl(&_VmSafe.CallOpts, rpcAlias) +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_VmSafe *VmSafeCaller) RpcUrlStructs(opts *bind.CallOpts) ([]VmSafeRpc, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "rpcUrlStructs") + + if err != nil { + return *new([]VmSafeRpc), err + } + + out0 := *abi.ConvertType(out[0], new([]VmSafeRpc)).(*[]VmSafeRpc) + + return out0, err + +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_VmSafe *VmSafeSession) RpcUrlStructs() ([]VmSafeRpc, error) { + return _VmSafe.Contract.RpcUrlStructs(&_VmSafe.CallOpts) +} + +// RpcUrlStructs is a free data retrieval call binding the contract method 0x9d2ad72a. +// +// Solidity: function rpcUrlStructs() view returns((string,string)[] urls) +func (_VmSafe *VmSafeCallerSession) RpcUrlStructs() ([]VmSafeRpc, error) { + return _VmSafe.Contract.RpcUrlStructs(&_VmSafe.CallOpts) +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_VmSafe *VmSafeCaller) RpcUrls(opts *bind.CallOpts) ([][2]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "rpcUrls") + + if err != nil { + return *new([][2]string), err + } + + out0 := *abi.ConvertType(out[0], new([][2]string)).(*[][2]string) + + return out0, err + +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_VmSafe *VmSafeSession) RpcUrls() ([][2]string, error) { + return _VmSafe.Contract.RpcUrls(&_VmSafe.CallOpts) +} + +// RpcUrls is a free data retrieval call binding the contract method 0xa85a8418. +// +// Solidity: function rpcUrls() view returns(string[2][] urls) +func (_VmSafe *VmSafeCallerSession) RpcUrls() ([][2]string, error) { + return _VmSafe.Contract.RpcUrls(&_VmSafe.CallOpts) +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCaller) Sign(opts *bind.CallOpts, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "sign", digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeSession) Sign(digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign(&_VmSafe.CallOpts, digest) +} + +// Sign is a free data retrieval call binding the contract method 0x799cd333. +// +// Solidity: function sign(bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCallerSession) Sign(digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign(&_VmSafe.CallOpts, digest) +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCaller) Sign0(opts *bind.CallOpts, signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "sign0", signer, digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeSession) Sign0(signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign0(&_VmSafe.CallOpts, signer, digest) +} + +// Sign0 is a free data retrieval call binding the contract method 0x8c1aa205. +// +// Solidity: function sign(address signer, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCallerSession) Sign0(signer common.Address, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign0(&_VmSafe.CallOpts, signer, digest) +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCaller) Sign2(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "sign2", privateKey, digest) + + outstruct := new(struct { + V uint8 + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.V = *abi.ConvertType(out[0], new(uint8)).(*uint8) + outstruct.R = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[2], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeSession) Sign2(privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign2(&_VmSafe.CallOpts, privateKey, digest) +} + +// Sign2 is a free data retrieval call binding the contract method 0xe341eaa4. +// +// Solidity: function sign(uint256 privateKey, bytes32 digest) pure returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCallerSession) Sign2(privateKey *big.Int, digest [32]byte) (struct { + V uint8 + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.Sign2(&_VmSafe.CallOpts, privateKey, digest) +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCaller) SignP256(opts *bind.CallOpts, privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "signP256", privateKey, digest) + + outstruct := new(struct { + R [32]byte + S [32]byte + }) + if err != nil { + return *outstruct, err + } + + outstruct.R = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + outstruct.S = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte) + + return *outstruct, err + +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_VmSafe *VmSafeSession) SignP256(privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.SignP256(&_VmSafe.CallOpts, privateKey, digest) +} + +// SignP256 is a free data retrieval call binding the contract method 0x83211b40. +// +// Solidity: function signP256(uint256 privateKey, bytes32 digest) pure returns(bytes32 r, bytes32 s) +func (_VmSafe *VmSafeCallerSession) SignP256(privateKey *big.Int, digest [32]byte) (struct { + R [32]byte + S [32]byte +}, error) { + return _VmSafe.Contract.SignP256(&_VmSafe.CallOpts, privateKey, digest) +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_VmSafe *VmSafeCaller) Split(opts *bind.CallOpts, input string, delimiter string) ([]string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "split", input, delimiter) + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_VmSafe *VmSafeSession) Split(input string, delimiter string) ([]string, error) { + return _VmSafe.Contract.Split(&_VmSafe.CallOpts, input, delimiter) +} + +// Split is a free data retrieval call binding the contract method 0x8bb75533. +// +// Solidity: function split(string input, string delimiter) pure returns(string[] outputs) +func (_VmSafe *VmSafeCallerSession) Split(input string, delimiter string) ([]string, error) { + return _VmSafe.Contract.Split(&_VmSafe.CallOpts, input, delimiter) +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_VmSafe *VmSafeCaller) ToBase64(opts *bind.CallOpts, data string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toBase64", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_VmSafe *VmSafeSession) ToBase64(data string) (string, error) { + return _VmSafe.Contract.ToBase64(&_VmSafe.CallOpts, data) +} + +// ToBase64 is a free data retrieval call binding the contract method 0x3f8be2c8. +// +// Solidity: function toBase64(string data) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ToBase64(data string) (string, error) { + return _VmSafe.Contract.ToBase64(&_VmSafe.CallOpts, data) +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_VmSafe *VmSafeCaller) ToBase640(opts *bind.CallOpts, data []byte) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toBase640", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_VmSafe *VmSafeSession) ToBase640(data []byte) (string, error) { + return _VmSafe.Contract.ToBase640(&_VmSafe.CallOpts, data) +} + +// ToBase640 is a free data retrieval call binding the contract method 0xa5cbfe65. +// +// Solidity: function toBase64(bytes data) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ToBase640(data []byte) (string, error) { + return _VmSafe.Contract.ToBase640(&_VmSafe.CallOpts, data) +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_VmSafe *VmSafeCaller) ToBase64URL(opts *bind.CallOpts, data string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toBase64URL", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_VmSafe *VmSafeSession) ToBase64URL(data string) (string, error) { + return _VmSafe.Contract.ToBase64URL(&_VmSafe.CallOpts, data) +} + +// ToBase64URL is a free data retrieval call binding the contract method 0xae3165b3. +// +// Solidity: function toBase64URL(string data) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ToBase64URL(data string) (string, error) { + return _VmSafe.Contract.ToBase64URL(&_VmSafe.CallOpts, data) +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_VmSafe *VmSafeCaller) ToBase64URL0(opts *bind.CallOpts, data []byte) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toBase64URL0", data) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_VmSafe *VmSafeSession) ToBase64URL0(data []byte) (string, error) { + return _VmSafe.Contract.ToBase64URL0(&_VmSafe.CallOpts, data) +} + +// ToBase64URL0 is a free data retrieval call binding the contract method 0xc8bd0e4a. +// +// Solidity: function toBase64URL(bytes data) pure returns(string) +func (_VmSafe *VmSafeCallerSession) ToBase64URL0(data []byte) (string, error) { + return _VmSafe.Contract.ToBase64URL0(&_VmSafe.CallOpts, data) +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_VmSafe *VmSafeCaller) ToLowercase(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toLowercase", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_VmSafe *VmSafeSession) ToLowercase(input string) (string, error) { + return _VmSafe.Contract.ToLowercase(&_VmSafe.CallOpts, input) +} + +// ToLowercase is a free data retrieval call binding the contract method 0x50bb0884. +// +// Solidity: function toLowercase(string input) pure returns(string output) +func (_VmSafe *VmSafeCallerSession) ToLowercase(input string) (string, error) { + return _VmSafe.Contract.ToLowercase(&_VmSafe.CallOpts, input) +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString(opts *bind.CallOpts, value common.Address) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString(value common.Address) (string, error) { + return _VmSafe.Contract.ToString(&_VmSafe.CallOpts, value) +} + +// ToString is a free data retrieval call binding the contract method 0x56ca623e. +// +// Solidity: function toString(address value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString(value common.Address) (string, error) { + return _VmSafe.Contract.ToString(&_VmSafe.CallOpts, value) +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString0(opts *bind.CallOpts, value *big.Int) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString0", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString0(value *big.Int) (string, error) { + return _VmSafe.Contract.ToString0(&_VmSafe.CallOpts, value) +} + +// ToString0 is a free data retrieval call binding the contract method 0x6900a3ae. +// +// Solidity: function toString(uint256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString0(value *big.Int) (string, error) { + return _VmSafe.Contract.ToString0(&_VmSafe.CallOpts, value) +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString1(opts *bind.CallOpts, value []byte) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString1", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString1(value []byte) (string, error) { + return _VmSafe.Contract.ToString1(&_VmSafe.CallOpts, value) +} + +// ToString1 is a free data retrieval call binding the contract method 0x71aad10d. +// +// Solidity: function toString(bytes value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString1(value []byte) (string, error) { + return _VmSafe.Contract.ToString1(&_VmSafe.CallOpts, value) +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString2(opts *bind.CallOpts, value bool) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString2", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString2(value bool) (string, error) { + return _VmSafe.Contract.ToString2(&_VmSafe.CallOpts, value) +} + +// ToString2 is a free data retrieval call binding the contract method 0x71dce7da. +// +// Solidity: function toString(bool value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString2(value bool) (string, error) { + return _VmSafe.Contract.ToString2(&_VmSafe.CallOpts, value) +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString3(opts *bind.CallOpts, value *big.Int) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString3", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString3(value *big.Int) (string, error) { + return _VmSafe.Contract.ToString3(&_VmSafe.CallOpts, value) +} + +// ToString3 is a free data retrieval call binding the contract method 0xa322c40e. +// +// Solidity: function toString(int256 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString3(value *big.Int) (string, error) { + return _VmSafe.Contract.ToString3(&_VmSafe.CallOpts, value) +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCaller) ToString4(opts *bind.CallOpts, value [32]byte) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toString4", value) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeSession) ToString4(value [32]byte) (string, error) { + return _VmSafe.Contract.ToString4(&_VmSafe.CallOpts, value) +} + +// ToString4 is a free data retrieval call binding the contract method 0xb11a19e8. +// +// Solidity: function toString(bytes32 value) pure returns(string stringifiedValue) +func (_VmSafe *VmSafeCallerSession) ToString4(value [32]byte) (string, error) { + return _VmSafe.Contract.ToString4(&_VmSafe.CallOpts, value) +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_VmSafe *VmSafeCaller) ToUppercase(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "toUppercase", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_VmSafe *VmSafeSession) ToUppercase(input string) (string, error) { + return _VmSafe.Contract.ToUppercase(&_VmSafe.CallOpts, input) +} + +// ToUppercase is a free data retrieval call binding the contract method 0x074ae3d7. +// +// Solidity: function toUppercase(string input) pure returns(string output) +func (_VmSafe *VmSafeCallerSession) ToUppercase(input string) (string, error) { + return _VmSafe.Contract.ToUppercase(&_VmSafe.CallOpts, input) +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_VmSafe *VmSafeCaller) Trim(opts *bind.CallOpts, input string) (string, error) { + var out []interface{} + err := _VmSafe.contract.Call(opts, &out, "trim", input) + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_VmSafe *VmSafeSession) Trim(input string) (string, error) { + return _VmSafe.Contract.Trim(&_VmSafe.CallOpts, input) +} + +// Trim is a free data retrieval call binding the contract method 0xb2dad155. +// +// Solidity: function trim(string input) pure returns(string output) +func (_VmSafe *VmSafeCallerSession) Trim(input string) (string, error) { + return _VmSafe.Contract.Trim(&_VmSafe.CallOpts, input) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_VmSafe *VmSafeTransactor) Accesses(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "accesses", target) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_VmSafe *VmSafeSession) Accesses(target common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.Accesses(&_VmSafe.TransactOpts, target) +} + +// Accesses is a paid mutator transaction binding the contract method 0x65bc9481. +// +// Solidity: function accesses(address target) returns(bytes32[] readSlots, bytes32[] writeSlots) +func (_VmSafe *VmSafeTransactorSession) Accesses(target common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.Accesses(&_VmSafe.TransactOpts, target) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_VmSafe *VmSafeTransactor) Breakpoint(opts *bind.TransactOpts, char string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "breakpoint", char) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_VmSafe *VmSafeSession) Breakpoint(char string) (*types.Transaction, error) { + return _VmSafe.Contract.Breakpoint(&_VmSafe.TransactOpts, char) +} + +// Breakpoint is a paid mutator transaction binding the contract method 0xf0259e92. +// +// Solidity: function breakpoint(string char) returns() +func (_VmSafe *VmSafeTransactorSession) Breakpoint(char string) (*types.Transaction, error) { + return _VmSafe.Contract.Breakpoint(&_VmSafe.TransactOpts, char) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_VmSafe *VmSafeTransactor) Breakpoint0(opts *bind.TransactOpts, char string, value bool) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "breakpoint0", char, value) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_VmSafe *VmSafeSession) Breakpoint0(char string, value bool) (*types.Transaction, error) { + return _VmSafe.Contract.Breakpoint0(&_VmSafe.TransactOpts, char, value) +} + +// Breakpoint0 is a paid mutator transaction binding the contract method 0xf7d39a8d. +// +// Solidity: function breakpoint(string char, bool value) returns() +func (_VmSafe *VmSafeTransactorSession) Breakpoint0(char string, value bool) (*types.Transaction, error) { + return _VmSafe.Contract.Breakpoint0(&_VmSafe.TransactOpts, char, value) +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_VmSafe *VmSafeTransactor) Broadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "broadcast") +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_VmSafe *VmSafeSession) Broadcast() (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast(&_VmSafe.TransactOpts) +} + +// Broadcast is a paid mutator transaction binding the contract method 0xafc98040. +// +// Solidity: function broadcast() returns() +func (_VmSafe *VmSafeTransactorSession) Broadcast() (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast(&_VmSafe.TransactOpts) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_VmSafe *VmSafeTransactor) Broadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "broadcast0", signer) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_VmSafe *VmSafeSession) Broadcast0(signer common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast0(&_VmSafe.TransactOpts, signer) +} + +// Broadcast0 is a paid mutator transaction binding the contract method 0xe6962cdb. +// +// Solidity: function broadcast(address signer) returns() +func (_VmSafe *VmSafeTransactorSession) Broadcast0(signer common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast0(&_VmSafe.TransactOpts, signer) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeTransactor) Broadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "broadcast1", privateKey) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast1(&_VmSafe.TransactOpts, privateKey) +} + +// Broadcast1 is a paid mutator transaction binding the contract method 0xf67a965b. +// +// Solidity: function broadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeTransactorSession) Broadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.Broadcast1(&_VmSafe.TransactOpts, privateKey) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_VmSafe *VmSafeTransactor) CloseFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "closeFile", path) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_VmSafe *VmSafeSession) CloseFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.CloseFile(&_VmSafe.TransactOpts, path) +} + +// CloseFile is a paid mutator transaction binding the contract method 0x48c3241f. +// +// Solidity: function closeFile(string path) returns() +func (_VmSafe *VmSafeTransactorSession) CloseFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.CloseFile(&_VmSafe.TransactOpts, path) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_VmSafe *VmSafeTransactor) CopyFile(opts *bind.TransactOpts, from string, to string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "copyFile", from, to) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_VmSafe *VmSafeSession) CopyFile(from string, to string) (*types.Transaction, error) { + return _VmSafe.Contract.CopyFile(&_VmSafe.TransactOpts, from, to) +} + +// CopyFile is a paid mutator transaction binding the contract method 0xa54a87d8. +// +// Solidity: function copyFile(string from, string to) returns(uint64 copied) +func (_VmSafe *VmSafeTransactorSession) CopyFile(from string, to string) (*types.Transaction, error) { + return _VmSafe.Contract.CopyFile(&_VmSafe.TransactOpts, from, to) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeTransactor) CreateDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "createDir", path, recursive) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeSession) CreateDir(path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.Contract.CreateDir(&_VmSafe.TransactOpts, path, recursive) +} + +// CreateDir is a paid mutator transaction binding the contract method 0x168b64d3. +// +// Solidity: function createDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeTransactorSession) CreateDir(path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.Contract.CreateDir(&_VmSafe.TransactOpts, path, recursive) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactor) CreateWallet(opts *bind.TransactOpts, walletLabel string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "createWallet", walletLabel) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeSession) CreateWallet(walletLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet(&_VmSafe.TransactOpts, walletLabel) +} + +// CreateWallet is a paid mutator transaction binding the contract method 0x7404f1d2. +// +// Solidity: function createWallet(string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactorSession) CreateWallet(walletLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet(&_VmSafe.TransactOpts, walletLabel) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactor) CreateWallet0(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "createWallet0", privateKey) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet0(&_VmSafe.TransactOpts, privateKey) +} + +// CreateWallet0 is a paid mutator transaction binding the contract method 0x7a675bb6. +// +// Solidity: function createWallet(uint256 privateKey) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactorSession) CreateWallet0(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet0(&_VmSafe.TransactOpts, privateKey) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactor) CreateWallet1(opts *bind.TransactOpts, privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "createWallet1", privateKey, walletLabel) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet1(&_VmSafe.TransactOpts, privateKey, walletLabel) +} + +// CreateWallet1 is a paid mutator transaction binding the contract method 0xed7c5462. +// +// Solidity: function createWallet(uint256 privateKey, string walletLabel) returns((address,uint256,uint256,uint256) wallet) +func (_VmSafe *VmSafeTransactorSession) CreateWallet1(privateKey *big.Int, walletLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.CreateWallet1(&_VmSafe.TransactOpts, privateKey, walletLabel) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_VmSafe *VmSafeTransactor) EthGetLogs(opts *bind.TransactOpts, fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "eth_getLogs", fromBlock, toBlock, target, topics) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_VmSafe *VmSafeSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.EthGetLogs(&_VmSafe.TransactOpts, fromBlock, toBlock, target, topics) +} + +// EthGetLogs is a paid mutator transaction binding the contract method 0x35e1349b. +// +// Solidity: function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] topics) returns((address,bytes32[],bytes,bytes32,uint64,bytes32,uint64,uint256,bool)[] logs) +func (_VmSafe *VmSafeTransactorSession) EthGetLogs(fromBlock *big.Int, toBlock *big.Int, target common.Address, topics [][32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.EthGetLogs(&_VmSafe.TransactOpts, fromBlock, toBlock, target, topics) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_VmSafe *VmSafeTransactor) Exists(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "exists", path) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_VmSafe *VmSafeSession) Exists(path string) (*types.Transaction, error) { + return _VmSafe.Contract.Exists(&_VmSafe.TransactOpts, path) +} + +// Exists is a paid mutator transaction binding the contract method 0x261a323e. +// +// Solidity: function exists(string path) returns(bool result) +func (_VmSafe *VmSafeTransactorSession) Exists(path string) (*types.Transaction, error) { + return _VmSafe.Contract.Exists(&_VmSafe.TransactOpts, path) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_VmSafe *VmSafeTransactor) Ffi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "ffi", commandInput) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_VmSafe *VmSafeSession) Ffi(commandInput []string) (*types.Transaction, error) { + return _VmSafe.Contract.Ffi(&_VmSafe.TransactOpts, commandInput) +} + +// Ffi is a paid mutator transaction binding the contract method 0x89160467. +// +// Solidity: function ffi(string[] commandInput) returns(bytes result) +func (_VmSafe *VmSafeTransactorSession) Ffi(commandInput []string) (*types.Transaction, error) { + return _VmSafe.Contract.Ffi(&_VmSafe.TransactOpts, commandInput) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_VmSafe *VmSafeTransactor) GetMappingKeyAndParentOf(opts *bind.TransactOpts, target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "getMappingKeyAndParentOf", target, elementSlot) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_VmSafe *VmSafeSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingKeyAndParentOf(&_VmSafe.TransactOpts, target, elementSlot) +} + +// GetMappingKeyAndParentOf is a paid mutator transaction binding the contract method 0x876e24e6. +// +// Solidity: function getMappingKeyAndParentOf(address target, bytes32 elementSlot) returns(bool found, bytes32 key, bytes32 parent) +func (_VmSafe *VmSafeTransactorSession) GetMappingKeyAndParentOf(target common.Address, elementSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingKeyAndParentOf(&_VmSafe.TransactOpts, target, elementSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_VmSafe *VmSafeTransactor) GetMappingLength(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "getMappingLength", target, mappingSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_VmSafe *VmSafeSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingLength(&_VmSafe.TransactOpts, target, mappingSlot) +} + +// GetMappingLength is a paid mutator transaction binding the contract method 0x2f2fd63f. +// +// Solidity: function getMappingLength(address target, bytes32 mappingSlot) returns(uint256 length) +func (_VmSafe *VmSafeTransactorSession) GetMappingLength(target common.Address, mappingSlot [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingLength(&_VmSafe.TransactOpts, target, mappingSlot) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_VmSafe *VmSafeTransactor) GetMappingSlotAt(opts *bind.TransactOpts, target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "getMappingSlotAt", target, mappingSlot, idx) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_VmSafe *VmSafeSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingSlotAt(&_VmSafe.TransactOpts, target, mappingSlot, idx) +} + +// GetMappingSlotAt is a paid mutator transaction binding the contract method 0xebc73ab4. +// +// Solidity: function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) returns(bytes32 value) +func (_VmSafe *VmSafeTransactorSession) GetMappingSlotAt(target common.Address, mappingSlot [32]byte, idx *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.GetMappingSlotAt(&_VmSafe.TransactOpts, target, mappingSlot, idx) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_VmSafe *VmSafeTransactor) GetNonce0(opts *bind.TransactOpts, wallet VmSafeWallet) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "getNonce0", wallet) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_VmSafe *VmSafeSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) { + return _VmSafe.Contract.GetNonce0(&_VmSafe.TransactOpts, wallet) +} + +// GetNonce0 is a paid mutator transaction binding the contract method 0xa5748aad. +// +// Solidity: function getNonce((address,uint256,uint256,uint256) wallet) returns(uint64 nonce) +func (_VmSafe *VmSafeTransactorSession) GetNonce0(wallet VmSafeWallet) (*types.Transaction, error) { + return _VmSafe.Contract.GetNonce0(&_VmSafe.TransactOpts, wallet) +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_VmSafe *VmSafeTransactor) GetRecordedLogs(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "getRecordedLogs") +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_VmSafe *VmSafeSession) GetRecordedLogs() (*types.Transaction, error) { + return _VmSafe.Contract.GetRecordedLogs(&_VmSafe.TransactOpts) +} + +// GetRecordedLogs is a paid mutator transaction binding the contract method 0x191553a4. +// +// Solidity: function getRecordedLogs() returns((bytes32[],bytes,address)[] logs) +func (_VmSafe *VmSafeTransactorSession) GetRecordedLogs() (*types.Transaction, error) { + return _VmSafe.Contract.GetRecordedLogs(&_VmSafe.TransactOpts) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_VmSafe *VmSafeTransactor) IsDir(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "isDir", path) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_VmSafe *VmSafeSession) IsDir(path string) (*types.Transaction, error) { + return _VmSafe.Contract.IsDir(&_VmSafe.TransactOpts, path) +} + +// IsDir is a paid mutator transaction binding the contract method 0x7d15d019. +// +// Solidity: function isDir(string path) returns(bool result) +func (_VmSafe *VmSafeTransactorSession) IsDir(path string) (*types.Transaction, error) { + return _VmSafe.Contract.IsDir(&_VmSafe.TransactOpts, path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_VmSafe *VmSafeTransactor) IsFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "isFile", path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_VmSafe *VmSafeSession) IsFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.IsFile(&_VmSafe.TransactOpts, path) +} + +// IsFile is a paid mutator transaction binding the contract method 0xe0eb04d4. +// +// Solidity: function isFile(string path) returns(bool result) +func (_VmSafe *VmSafeTransactorSession) IsFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.IsFile(&_VmSafe.TransactOpts, path) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_VmSafe *VmSafeTransactor) Label(opts *bind.TransactOpts, account common.Address, newLabel string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "label", account, newLabel) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_VmSafe *VmSafeSession) Label(account common.Address, newLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.Label(&_VmSafe.TransactOpts, account, newLabel) +} + +// Label is a paid mutator transaction binding the contract method 0xc657c718. +// +// Solidity: function label(address account, string newLabel) returns() +func (_VmSafe *VmSafeTransactorSession) Label(account common.Address, newLabel string) (*types.Transaction, error) { + return _VmSafe.Contract.Label(&_VmSafe.TransactOpts, account, newLabel) +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_VmSafe *VmSafeTransactor) PauseGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "pauseGasMetering") +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_VmSafe *VmSafeSession) PauseGasMetering() (*types.Transaction, error) { + return _VmSafe.Contract.PauseGasMetering(&_VmSafe.TransactOpts) +} + +// PauseGasMetering is a paid mutator transaction binding the contract method 0xd1a5b36f. +// +// Solidity: function pauseGasMetering() returns() +func (_VmSafe *VmSafeTransactorSession) PauseGasMetering() (*types.Transaction, error) { + return _VmSafe.Contract.PauseGasMetering(&_VmSafe.TransactOpts) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_VmSafe *VmSafeTransactor) Prompt(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "prompt", promptText) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_VmSafe *VmSafeSession) Prompt(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.Prompt(&_VmSafe.TransactOpts, promptText) +} + +// Prompt is a paid mutator transaction binding the contract method 0x47eaf474. +// +// Solidity: function prompt(string promptText) returns(string input) +func (_VmSafe *VmSafeTransactorSession) Prompt(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.Prompt(&_VmSafe.TransactOpts, promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_VmSafe *VmSafeTransactor) PromptAddress(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "promptAddress", promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_VmSafe *VmSafeSession) PromptAddress(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptAddress(&_VmSafe.TransactOpts, promptText) +} + +// PromptAddress is a paid mutator transaction binding the contract method 0x62ee05f4. +// +// Solidity: function promptAddress(string promptText) returns(address) +func (_VmSafe *VmSafeTransactorSession) PromptAddress(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptAddress(&_VmSafe.TransactOpts, promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_VmSafe *VmSafeTransactor) PromptSecret(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "promptSecret", promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_VmSafe *VmSafeSession) PromptSecret(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptSecret(&_VmSafe.TransactOpts, promptText) +} + +// PromptSecret is a paid mutator transaction binding the contract method 0x1e279d41. +// +// Solidity: function promptSecret(string promptText) returns(string input) +func (_VmSafe *VmSafeTransactorSession) PromptSecret(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptSecret(&_VmSafe.TransactOpts, promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeTransactor) PromptSecretUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "promptSecretUint", promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeSession) PromptSecretUint(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptSecretUint(&_VmSafe.TransactOpts, promptText) +} + +// PromptSecretUint is a paid mutator transaction binding the contract method 0x69ca02b7. +// +// Solidity: function promptSecretUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeTransactorSession) PromptSecretUint(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptSecretUint(&_VmSafe.TransactOpts, promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeTransactor) PromptUint(opts *bind.TransactOpts, promptText string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "promptUint", promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeSession) PromptUint(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptUint(&_VmSafe.TransactOpts, promptText) +} + +// PromptUint is a paid mutator transaction binding the contract method 0x652fd489. +// +// Solidity: function promptUint(string promptText) returns(uint256) +func (_VmSafe *VmSafeTransactorSession) PromptUint(promptText string) (*types.Transaction, error) { + return _VmSafe.Contract.PromptUint(&_VmSafe.TransactOpts, promptText) +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_VmSafe *VmSafeTransactor) RandomAddress(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "randomAddress") +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_VmSafe *VmSafeSession) RandomAddress() (*types.Transaction, error) { + return _VmSafe.Contract.RandomAddress(&_VmSafe.TransactOpts) +} + +// RandomAddress is a paid mutator transaction binding the contract method 0xd5bee9f5. +// +// Solidity: function randomAddress() returns(address) +func (_VmSafe *VmSafeTransactorSession) RandomAddress() (*types.Transaction, error) { + return _VmSafe.Contract.RandomAddress(&_VmSafe.TransactOpts) +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_VmSafe *VmSafeTransactor) RandomUint(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "randomUint") +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_VmSafe *VmSafeSession) RandomUint() (*types.Transaction, error) { + return _VmSafe.Contract.RandomUint(&_VmSafe.TransactOpts) +} + +// RandomUint is a paid mutator transaction binding the contract method 0x25124730. +// +// Solidity: function randomUint() returns(uint256) +func (_VmSafe *VmSafeTransactorSession) RandomUint() (*types.Transaction, error) { + return _VmSafe.Contract.RandomUint(&_VmSafe.TransactOpts) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_VmSafe *VmSafeTransactor) RandomUint0(opts *bind.TransactOpts, min *big.Int, max *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "randomUint0", min, max) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_VmSafe *VmSafeSession) RandomUint0(min *big.Int, max *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.RandomUint0(&_VmSafe.TransactOpts, min, max) +} + +// RandomUint0 is a paid mutator transaction binding the contract method 0xd61b051b. +// +// Solidity: function randomUint(uint256 min, uint256 max) returns(uint256) +func (_VmSafe *VmSafeTransactorSession) RandomUint0(min *big.Int, max *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.RandomUint0(&_VmSafe.TransactOpts, min, max) +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_VmSafe *VmSafeTransactor) Record(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "record") +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_VmSafe *VmSafeSession) Record() (*types.Transaction, error) { + return _VmSafe.Contract.Record(&_VmSafe.TransactOpts) +} + +// Record is a paid mutator transaction binding the contract method 0x266cf109. +// +// Solidity: function record() returns() +func (_VmSafe *VmSafeTransactorSession) Record() (*types.Transaction, error) { + return _VmSafe.Contract.Record(&_VmSafe.TransactOpts) +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_VmSafe *VmSafeTransactor) RecordLogs(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "recordLogs") +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_VmSafe *VmSafeSession) RecordLogs() (*types.Transaction, error) { + return _VmSafe.Contract.RecordLogs(&_VmSafe.TransactOpts) +} + +// RecordLogs is a paid mutator transaction binding the contract method 0x41af2f52. +// +// Solidity: function recordLogs() returns() +func (_VmSafe *VmSafeTransactorSession) RecordLogs() (*types.Transaction, error) { + return _VmSafe.Contract.RecordLogs(&_VmSafe.TransactOpts) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_VmSafe *VmSafeTransactor) RememberKey(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "rememberKey", privateKey) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_VmSafe *VmSafeSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.RememberKey(&_VmSafe.TransactOpts, privateKey) +} + +// RememberKey is a paid mutator transaction binding the contract method 0x22100064. +// +// Solidity: function rememberKey(uint256 privateKey) returns(address keyAddr) +func (_VmSafe *VmSafeTransactorSession) RememberKey(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.RememberKey(&_VmSafe.TransactOpts, privateKey) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeTransactor) RemoveDir(opts *bind.TransactOpts, path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "removeDir", path, recursive) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.Contract.RemoveDir(&_VmSafe.TransactOpts, path, recursive) +} + +// RemoveDir is a paid mutator transaction binding the contract method 0x45c62011. +// +// Solidity: function removeDir(string path, bool recursive) returns() +func (_VmSafe *VmSafeTransactorSession) RemoveDir(path string, recursive bool) (*types.Transaction, error) { + return _VmSafe.Contract.RemoveDir(&_VmSafe.TransactOpts, path, recursive) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_VmSafe *VmSafeTransactor) RemoveFile(opts *bind.TransactOpts, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "removeFile", path) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_VmSafe *VmSafeSession) RemoveFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.RemoveFile(&_VmSafe.TransactOpts, path) +} + +// RemoveFile is a paid mutator transaction binding the contract method 0xf1afe04d. +// +// Solidity: function removeFile(string path) returns() +func (_VmSafe *VmSafeTransactorSession) RemoveFile(path string) (*types.Transaction, error) { + return _VmSafe.Contract.RemoveFile(&_VmSafe.TransactOpts, path) +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_VmSafe *VmSafeTransactor) ResumeGasMetering(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "resumeGasMetering") +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_VmSafe *VmSafeSession) ResumeGasMetering() (*types.Transaction, error) { + return _VmSafe.Contract.ResumeGasMetering(&_VmSafe.TransactOpts) +} + +// ResumeGasMetering is a paid mutator transaction binding the contract method 0x2bcd50e0. +// +// Solidity: function resumeGasMetering() returns() +func (_VmSafe *VmSafeTransactorSession) ResumeGasMetering() (*types.Transaction, error) { + return _VmSafe.Contract.ResumeGasMetering(&_VmSafe.TransactOpts) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_VmSafe *VmSafeTransactor) Rpc(opts *bind.TransactOpts, method string, params string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "rpc", method, params) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_VmSafe *VmSafeSession) Rpc(method string, params string) (*types.Transaction, error) { + return _VmSafe.Contract.Rpc(&_VmSafe.TransactOpts, method, params) +} + +// Rpc is a paid mutator transaction binding the contract method 0x1206c8a8. +// +// Solidity: function rpc(string method, string params) returns(bytes data) +func (_VmSafe *VmSafeTransactorSession) Rpc(method string, params string) (*types.Transaction, error) { + return _VmSafe.Contract.Rpc(&_VmSafe.TransactOpts, method, params) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeAddress(opts *bind.TransactOpts, objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeAddress", objectKey, valueKey, values) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeAddress(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeAddress is a paid mutator transaction binding the contract method 0x1e356e1a. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeAddress(objectKey string, valueKey string, values []common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeAddress(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeAddress0(opts *bind.TransactOpts, objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeAddress0", objectKey, valueKey, value) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeAddress0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeAddress0 is a paid mutator transaction binding the contract method 0x972c6062. +// +// Solidity: function serializeAddress(string objectKey, string valueKey, address value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeAddress0(objectKey string, valueKey string, value common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeAddress0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBool(opts *bind.TransactOpts, objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBool", objectKey, valueKey, values) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBool(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBool is a paid mutator transaction binding the contract method 0x92925aa1. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBool(objectKey string, valueKey string, values []bool) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBool(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBool0(opts *bind.TransactOpts, objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBool0", objectKey, valueKey, value) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBool0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBool0 is a paid mutator transaction binding the contract method 0xac22e971. +// +// Solidity: function serializeBool(string objectKey, string valueKey, bool value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBool0(objectKey string, valueKey string, value bool) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBool0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBytes(opts *bind.TransactOpts, objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBytes", objectKey, valueKey, values) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes is a paid mutator transaction binding the contract method 0x9884b232. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBytes(objectKey string, valueKey string, values [][]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBytes0(opts *bind.TransactOpts, objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBytes0", objectKey, valueKey, value) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes0 is a paid mutator transaction binding the contract method 0xf21d52c7. +// +// Solidity: function serializeBytes(string objectKey, string valueKey, bytes value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBytes0(objectKey string, valueKey string, value []byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBytes32(opts *bind.TransactOpts, objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBytes32", objectKey, valueKey, values) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes32(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes32 is a paid mutator transaction binding the contract method 0x201e43e2. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBytes32(objectKey string, valueKey string, values [][32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes32(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeBytes320(opts *bind.TransactOpts, objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeBytes320", objectKey, valueKey, value) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes320(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeBytes320 is a paid mutator transaction binding the contract method 0x2d812b44. +// +// Solidity: function serializeBytes32(string objectKey, string valueKey, bytes32 value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeBytes320(objectKey string, valueKey string, value [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeBytes320(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeInt(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeInt", objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeInt(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt is a paid mutator transaction binding the contract method 0x3f33db60. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256 value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeInt(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeInt(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeInt0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeInt0", objectKey, valueKey, values) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeInt0(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeInt0 is a paid mutator transaction binding the contract method 0x7676e127. +// +// Solidity: function serializeInt(string objectKey, string valueKey, int256[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeInt0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeInt0(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeJson(opts *bind.TransactOpts, objectKey string, value string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeJson", objectKey, value) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeJson(&_VmSafe.TransactOpts, objectKey, value) +} + +// SerializeJson is a paid mutator transaction binding the contract method 0x9b3358b0. +// +// Solidity: function serializeJson(string objectKey, string value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeJson(objectKey string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeJson(&_VmSafe.TransactOpts, objectKey, value) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeString(opts *bind.TransactOpts, objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeString", objectKey, valueKey, values) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeString(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeString is a paid mutator transaction binding the contract method 0x561cd6f3. +// +// Solidity: function serializeString(string objectKey, string valueKey, string[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeString(objectKey string, valueKey string, values []string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeString(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeString0(opts *bind.TransactOpts, objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeString0", objectKey, valueKey, value) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeString0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeString0 is a paid mutator transaction binding the contract method 0x88da6d35. +// +// Solidity: function serializeString(string objectKey, string valueKey, string value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeString0(objectKey string, valueKey string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeString0(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeUint(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeUint", objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUint(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint is a paid mutator transaction binding the contract method 0x129e9002. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeUint(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUint(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeUint0(opts *bind.TransactOpts, objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeUint0", objectKey, valueKey, values) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_VmSafe *VmSafeSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUint0(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeUint0 is a paid mutator transaction binding the contract method 0xfee9a469. +// +// Solidity: function serializeUint(string objectKey, string valueKey, uint256[] values) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeUint0(objectKey string, valueKey string, values []*big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUint0(&_VmSafe.TransactOpts, objectKey, valueKey, values) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeTransactor) SerializeUintToHex(opts *bind.TransactOpts, objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "serializeUintToHex", objectKey, valueKey, value) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUintToHex(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SerializeUintToHex is a paid mutator transaction binding the contract method 0xae5a2ae8. +// +// Solidity: function serializeUintToHex(string objectKey, string valueKey, uint256 value) returns(string json) +func (_VmSafe *VmSafeTransactorSession) SerializeUintToHex(objectKey string, valueKey string, value *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.SerializeUintToHex(&_VmSafe.TransactOpts, objectKey, valueKey, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_VmSafe *VmSafeTransactor) SetEnv(opts *bind.TransactOpts, name string, value string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "setEnv", name, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_VmSafe *VmSafeSession) SetEnv(name string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SetEnv(&_VmSafe.TransactOpts, name, value) +} + +// SetEnv is a paid mutator transaction binding the contract method 0x3d5923ee. +// +// Solidity: function setEnv(string name, string value) returns() +func (_VmSafe *VmSafeTransactorSession) SetEnv(name string, value string) (*types.Transaction, error) { + return _VmSafe.Contract.SetEnv(&_VmSafe.TransactOpts, name, value) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeTransactor) Sign1(opts *bind.TransactOpts, wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "sign1", wallet, digest) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.Sign1(&_VmSafe.TransactOpts, wallet, digest) +} + +// Sign1 is a paid mutator transaction binding the contract method 0xb25c5a25. +// +// Solidity: function sign((address,uint256,uint256,uint256) wallet, bytes32 digest) returns(uint8 v, bytes32 r, bytes32 s) +func (_VmSafe *VmSafeTransactorSession) Sign1(wallet VmSafeWallet, digest [32]byte) (*types.Transaction, error) { + return _VmSafe.Contract.Sign1(&_VmSafe.TransactOpts, wallet, digest) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_VmSafe *VmSafeTransactor) Sleep(opts *bind.TransactOpts, duration *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "sleep", duration) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_VmSafe *VmSafeSession) Sleep(duration *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.Sleep(&_VmSafe.TransactOpts, duration) +} + +// Sleep is a paid mutator transaction binding the contract method 0xfa9d8713. +// +// Solidity: function sleep(uint256 duration) returns() +func (_VmSafe *VmSafeTransactorSession) Sleep(duration *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.Sleep(&_VmSafe.TransactOpts, duration) +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_VmSafe *VmSafeTransactor) StartBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "startBroadcast") +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_VmSafe *VmSafeSession) StartBroadcast() (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast(&_VmSafe.TransactOpts) +} + +// StartBroadcast is a paid mutator transaction binding the contract method 0x7fb5297f. +// +// Solidity: function startBroadcast() returns() +func (_VmSafe *VmSafeTransactorSession) StartBroadcast() (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast(&_VmSafe.TransactOpts) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_VmSafe *VmSafeTransactor) StartBroadcast0(opts *bind.TransactOpts, signer common.Address) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "startBroadcast0", signer) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_VmSafe *VmSafeSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast0(&_VmSafe.TransactOpts, signer) +} + +// StartBroadcast0 is a paid mutator transaction binding the contract method 0x7fec2a8d. +// +// Solidity: function startBroadcast(address signer) returns() +func (_VmSafe *VmSafeTransactorSession) StartBroadcast0(signer common.Address) (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast0(&_VmSafe.TransactOpts, signer) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeTransactor) StartBroadcast1(opts *bind.TransactOpts, privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "startBroadcast1", privateKey) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast1(&_VmSafe.TransactOpts, privateKey) +} + +// StartBroadcast1 is a paid mutator transaction binding the contract method 0xce817d47. +// +// Solidity: function startBroadcast(uint256 privateKey) returns() +func (_VmSafe *VmSafeTransactorSession) StartBroadcast1(privateKey *big.Int) (*types.Transaction, error) { + return _VmSafe.Contract.StartBroadcast1(&_VmSafe.TransactOpts, privateKey) +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_VmSafe *VmSafeTransactor) StartMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "startMappingRecording") +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_VmSafe *VmSafeSession) StartMappingRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StartMappingRecording(&_VmSafe.TransactOpts) +} + +// StartMappingRecording is a paid mutator transaction binding the contract method 0x3e9705c0. +// +// Solidity: function startMappingRecording() returns() +func (_VmSafe *VmSafeTransactorSession) StartMappingRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StartMappingRecording(&_VmSafe.TransactOpts) +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_VmSafe *VmSafeTransactor) StartStateDiffRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "startStateDiffRecording") +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_VmSafe *VmSafeSession) StartStateDiffRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StartStateDiffRecording(&_VmSafe.TransactOpts) +} + +// StartStateDiffRecording is a paid mutator transaction binding the contract method 0xcf22e3c9. +// +// Solidity: function startStateDiffRecording() returns() +func (_VmSafe *VmSafeTransactorSession) StartStateDiffRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StartStateDiffRecording(&_VmSafe.TransactOpts) +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_VmSafe *VmSafeTransactor) StopAndReturnStateDiff(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "stopAndReturnStateDiff") +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_VmSafe *VmSafeSession) StopAndReturnStateDiff() (*types.Transaction, error) { + return _VmSafe.Contract.StopAndReturnStateDiff(&_VmSafe.TransactOpts) +} + +// StopAndReturnStateDiff is a paid mutator transaction binding the contract method 0xaa5cf90e. +// +// Solidity: function stopAndReturnStateDiff() returns(((uint256,uint256),uint8,address,address,bool,uint256,uint256,bytes,uint256,bytes,bool,(address,bytes32,bool,bytes32,bytes32,bool)[],uint64)[] accountAccesses) +func (_VmSafe *VmSafeTransactorSession) StopAndReturnStateDiff() (*types.Transaction, error) { + return _VmSafe.Contract.StopAndReturnStateDiff(&_VmSafe.TransactOpts) +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_VmSafe *VmSafeTransactor) StopBroadcast(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "stopBroadcast") +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_VmSafe *VmSafeSession) StopBroadcast() (*types.Transaction, error) { + return _VmSafe.Contract.StopBroadcast(&_VmSafe.TransactOpts) +} + +// StopBroadcast is a paid mutator transaction binding the contract method 0x76eadd36. +// +// Solidity: function stopBroadcast() returns() +func (_VmSafe *VmSafeTransactorSession) StopBroadcast() (*types.Transaction, error) { + return _VmSafe.Contract.StopBroadcast(&_VmSafe.TransactOpts) +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_VmSafe *VmSafeTransactor) StopMappingRecording(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "stopMappingRecording") +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_VmSafe *VmSafeSession) StopMappingRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StopMappingRecording(&_VmSafe.TransactOpts) +} + +// StopMappingRecording is a paid mutator transaction binding the contract method 0x0d4aae9b. +// +// Solidity: function stopMappingRecording() returns() +func (_VmSafe *VmSafeTransactorSession) StopMappingRecording() (*types.Transaction, error) { + return _VmSafe.Contract.StopMappingRecording(&_VmSafe.TransactOpts) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_VmSafe *VmSafeTransactor) TryFfi(opts *bind.TransactOpts, commandInput []string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "tryFfi", commandInput) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_VmSafe *VmSafeSession) TryFfi(commandInput []string) (*types.Transaction, error) { + return _VmSafe.Contract.TryFfi(&_VmSafe.TransactOpts, commandInput) +} + +// TryFfi is a paid mutator transaction binding the contract method 0xf45c1ce7. +// +// Solidity: function tryFfi(string[] commandInput) returns((int32,bytes,bytes) result) +func (_VmSafe *VmSafeTransactorSession) TryFfi(commandInput []string) (*types.Transaction, error) { + return _VmSafe.Contract.TryFfi(&_VmSafe.TransactOpts, commandInput) +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_VmSafe *VmSafeTransactor) UnixTime(opts *bind.TransactOpts) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "unixTime") +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_VmSafe *VmSafeSession) UnixTime() (*types.Transaction, error) { + return _VmSafe.Contract.UnixTime(&_VmSafe.TransactOpts) +} + +// UnixTime is a paid mutator transaction binding the contract method 0x625387dc. +// +// Solidity: function unixTime() returns(uint256 milliseconds) +func (_VmSafe *VmSafeTransactorSession) UnixTime() (*types.Transaction, error) { + return _VmSafe.Contract.UnixTime(&_VmSafe.TransactOpts) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_VmSafe *VmSafeTransactor) WriteFile(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeFile", path, data) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_VmSafe *VmSafeSession) WriteFile(path string, data string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteFile(&_VmSafe.TransactOpts, path, data) +} + +// WriteFile is a paid mutator transaction binding the contract method 0x897e0a97. +// +// Solidity: function writeFile(string path, string data) returns() +func (_VmSafe *VmSafeTransactorSession) WriteFile(path string, data string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteFile(&_VmSafe.TransactOpts, path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_VmSafe *VmSafeTransactor) WriteFileBinary(opts *bind.TransactOpts, path string, data []byte) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeFileBinary", path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_VmSafe *VmSafeSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) { + return _VmSafe.Contract.WriteFileBinary(&_VmSafe.TransactOpts, path, data) +} + +// WriteFileBinary is a paid mutator transaction binding the contract method 0x1f21fc80. +// +// Solidity: function writeFileBinary(string path, bytes data) returns() +func (_VmSafe *VmSafeTransactorSession) WriteFileBinary(path string, data []byte) (*types.Transaction, error) { + return _VmSafe.Contract.WriteFileBinary(&_VmSafe.TransactOpts, path, data) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeTransactor) WriteJson(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeJson", json, path, valueKey) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteJson(&_VmSafe.TransactOpts, json, path, valueKey) +} + +// WriteJson is a paid mutator transaction binding the contract method 0x35d6ad46. +// +// Solidity: function writeJson(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeTransactorSession) WriteJson(json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteJson(&_VmSafe.TransactOpts, json, path, valueKey) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_VmSafe *VmSafeTransactor) WriteJson0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeJson0", json, path) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_VmSafe *VmSafeSession) WriteJson0(json string, path string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteJson0(&_VmSafe.TransactOpts, json, path) +} + +// WriteJson0 is a paid mutator transaction binding the contract method 0xe23cd19f. +// +// Solidity: function writeJson(string json, string path) returns() +func (_VmSafe *VmSafeTransactorSession) WriteJson0(json string, path string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteJson0(&_VmSafe.TransactOpts, json, path) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_VmSafe *VmSafeTransactor) WriteLine(opts *bind.TransactOpts, path string, data string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeLine", path, data) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_VmSafe *VmSafeSession) WriteLine(path string, data string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteLine(&_VmSafe.TransactOpts, path, data) +} + +// WriteLine is a paid mutator transaction binding the contract method 0x619d897f. +// +// Solidity: function writeLine(string path, string data) returns() +func (_VmSafe *VmSafeTransactorSession) WriteLine(path string, data string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteLine(&_VmSafe.TransactOpts, path, data) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeTransactor) WriteToml(opts *bind.TransactOpts, json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeToml", json, path, valueKey) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteToml(&_VmSafe.TransactOpts, json, path, valueKey) +} + +// WriteToml is a paid mutator transaction binding the contract method 0x51ac6a33. +// +// Solidity: function writeToml(string json, string path, string valueKey) returns() +func (_VmSafe *VmSafeTransactorSession) WriteToml(json string, path string, valueKey string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteToml(&_VmSafe.TransactOpts, json, path, valueKey) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_VmSafe *VmSafeTransactor) WriteToml0(opts *bind.TransactOpts, json string, path string) (*types.Transaction, error) { + return _VmSafe.contract.Transact(opts, "writeToml0", json, path) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_VmSafe *VmSafeSession) WriteToml0(json string, path string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteToml0(&_VmSafe.TransactOpts, json, path) +} + +// WriteToml0 is a paid mutator transaction binding the contract method 0xc0865ba7. +// +// Solidity: function writeToml(string json, string path) returns() +func (_VmSafe *VmSafeTransactorSession) WriteToml0(json string, path string) (*types.Transaction, error) { + return _VmSafe.Contract.WriteToml0(&_VmSafe.TransactOpts, json, path) +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest.ts new file mode 100644 index 00000000..0572c60f --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest.ts @@ -0,0 +1,1023 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface GatewayEVMTestInterface extends utils.Interface { + functions: { + "IS_TEST()": FunctionFragment; + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "failed()": FunctionFragment; + "setUp()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + "testForwardCallToReceivePayable()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "IS_TEST" + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "failed" + | "setUp" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + | "testForwardCallToReceivePayable" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string; + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + encodeFunctionData(functionFragment: "setUp", values?: undefined): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "testForwardCallToReceivePayable", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setUp", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "testForwardCallToReceivePayable", + data: BytesLike + ): Result; + + events: { + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface GatewayEVMTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + IS_TEST(overrides?: CallOverrides): Promise<[boolean]>; + + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + failed(overrides?: CallOverrides): Promise<[boolean]>; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable(overrides?: CallOverrides): Promise; + }; + + filters: { + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts new file mode 100644 index 00000000..5c8fc539 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { GatewayEVMTest } from "./GatewayEVMTest"; diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 939b9af8..39d20d80 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -1,6 +1,8 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +import type * as gatewayEvmTSol from "./GatewayEVM.t.sol"; +export type { gatewayEvmTSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts index 2c88b298..bdfda457 100644 --- a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVM.ts @@ -28,16 +28,10 @@ export interface IGatewayEVMInterface extends utils.Interface { functions: { "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; - "send(bytes,uint256)": FunctionFragment; - "sendERC20(bytes,address,uint256)": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: - | "execute" - | "executeWithERC20" - | "send" - | "sendERC20" + nameOrSignatureOrTopic: "execute" | "executeWithERC20" ): FunctionFragment; encodeFunctionData( @@ -53,26 +47,12 @@ export interface IGatewayEVMInterface extends utils.Interface { PromiseOrValue ] ): string; - encodeFunctionData( - functionFragment: "send", - values: [PromiseOrValue, PromiseOrValue] - ): string; - encodeFunctionData( - functionFragment: "sendERC20", - values: [ - PromiseOrValue, - PromiseOrValue, - PromiseOrValue - ] - ): string; decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult( functionFragment: "executeWithERC20", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; events: {}; } @@ -117,19 +97,6 @@ export interface IGatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - asset: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; }; execute( @@ -146,19 +113,6 @@ export interface IGatewayEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - asset: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - callStatic: { execute( destination: PromiseOrValue, @@ -173,19 +127,6 @@ export interface IGatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: CallOverrides ): Promise; - - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: CallOverrides - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - asset: PromiseOrValue, - amount: PromiseOrValue, - overrides?: CallOverrides - ): Promise; }; filters: {}; @@ -204,19 +145,6 @@ export interface IGatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - asset: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; }; populateTransaction: { @@ -233,18 +161,5 @@ export interface IGatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - asset: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors.ts new file mode 100644 index 00000000..83722e4a --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface IGatewayEVMErrors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents.ts new file mode 100644 index 00000000..5346a379 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents.ts @@ -0,0 +1,165 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface IGatewayEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents.ts new file mode 100644 index 00000000..b29196dc --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents.ts @@ -0,0 +1,162 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IReceiverEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; +} + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface IReceiverEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IReceiverEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts index a354144f..87e4491f 100644 --- a/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts +++ b/typechain-types/contracts/prototypes/evm/interfaces.sol/index.ts @@ -2,3 +2,6 @@ /* tslint:disable */ /* eslint-disable */ export type { IGatewayEVM } from "./IGatewayEVM"; +export type { IGatewayEVMErrors } from "./IGatewayEVMErrors"; +export type { IGatewayEVMEvents } from "./IGatewayEVMEvents"; +export type { IReceiverEVMEvents } from "./IReceiverEVMEvents"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index b3701baa..bb8520c3 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -149,7 +149,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory.ts new file mode 100644 index 00000000..b933279a --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -0,0 +1,910 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../../common"; +import type { + GatewayEVMTest, + GatewayEVMTestInterface, +} from "../../../../../contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "IS_TEST", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "setUp", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "testForwardCallToReceivePayable", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVMTest__factory extends ContractFactory { + constructor(...args: GatewayEVMTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVMTest { + return super.attach(address) as GatewayEVMTest; + } + override connect(signer: Signer): GatewayEVMTest__factory { + return super.connect(signer) as GatewayEVMTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMTestInterface { + return new utils.Interface(_abi) as GatewayEVMTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVMTest { + return new Contract(address, _abi, signerOrProvider) as GatewayEVMTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts new file mode 100644 index 00000000..9427818e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { GatewayEVMTest__factory } from "./GatewayEVMTest__factory"; diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index de37e8d2..3203cdfb 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -535,7 +535,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index b7a35400..10853123 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -1,6 +1,7 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ +export * as gatewayEvmTSol from "./GatewayEVM.t.sol"; export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory.ts new file mode 100644 index 00000000..72c92896 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory.ts @@ -0,0 +1,61 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVMErrors, + IGatewayEVMErrorsInterface, +} from "../../../../../contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, +] as const; + +export class IGatewayEVMErrors__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMErrorsInterface { + return new utils.Interface(_abi) as IGatewayEVMErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVMErrors { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVMErrors; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory.ts new file mode 100644 index 00000000..0e996a00 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory.ts @@ -0,0 +1,144 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVMEvents, + IGatewayEVMEventsInterface, +} from "../../../../../contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, +] as const; + +export class IGatewayEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMEventsInterface { + return new utils.Interface(_abi) as IGatewayEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts index d901f6b5..5dc716c4 100644 --- a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory.ts @@ -68,47 +68,6 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, - { - inputs: [ - { - internalType: "bytes", - name: "recipient", - type: "bytes", - }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, - ], - name: "send", - outputs: [], - stateMutability: "payable", - type: "function", - }, - { - inputs: [ - { - internalType: "bytes", - name: "recipient", - type: "bytes", - }, - { - internalType: "address", - name: "asset", - type: "address", - }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, - ], - name: "sendERC20", - outputs: [], - stateMutability: "nonpayable", - type: "function", - }, ] as const; export class IGatewayEVM__factory { diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory.ts new file mode 100644 index 00000000..9f9d68c4 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory.ts @@ -0,0 +1,138 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IReceiverEVMEvents, + IReceiverEVMEventsInterface, +} from "../../../../../contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, +] as const; + +export class IReceiverEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IReceiverEVMEventsInterface { + return new utils.Interface(_abi) as IReceiverEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IReceiverEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IReceiverEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts index 1b765f1f..0f9f3b51 100644 --- a/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/interfaces.sol/index.ts @@ -2,3 +2,6 @@ /* tslint:disable */ /* eslint-disable */ export { IGatewayEVM__factory } from "./IGatewayEVM__factory"; +export { IGatewayEVMErrors__factory } from "./IGatewayEVMErrors__factory"; +export { IGatewayEVMEvents__factory } from "./IGatewayEVMEvents__factory"; +export { IReceiverEVMEvents__factory } from "./IReceiverEVMEvents__factory"; diff --git a/typechain-types/factories/forge-std/StdAssertions__factory.ts b/typechain-types/factories/forge-std/StdAssertions__factory.ts new file mode 100644 index 00000000..5fc55ec1 --- /dev/null +++ b/typechain-types/factories/forge-std/StdAssertions__factory.ts @@ -0,0 +1,403 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + StdAssertions, + StdAssertionsInterface, +} from "../../forge-std/StdAssertions"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class StdAssertions__factory { + static readonly abi = _abi; + static createInterface(): StdAssertionsInterface { + return new utils.Interface(_abi) as StdAssertionsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): StdAssertions { + return new Contract(address, _abi, signerOrProvider) as StdAssertions; + } +} diff --git a/typechain-types/factories/forge-std/StdError.sol/StdError__factory.ts b/typechain-types/factories/forge-std/StdError.sol/StdError__factory.ts new file mode 100644 index 00000000..0bdc6b38 --- /dev/null +++ b/typechain-types/factories/forge-std/StdError.sol/StdError__factory.ts @@ -0,0 +1,180 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + StdError, + StdErrorInterface, +} from "../../../forge-std/StdError.sol/StdError"; + +const _abi = [ + { + inputs: [], + name: "arithmeticError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "assertionError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "divisionError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "encodeStorageError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "enumConversionError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "indexOOBError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "memOverflowError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "popError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "zeroVarError", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type StdErrorConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: StdErrorConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class StdError__factory extends ContractFactory { + constructor(...args: StdErrorConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): StdError { + return super.attach(address) as StdError; + } + override connect(signer: Signer): StdError__factory { + return super.connect(signer) as StdError__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): StdErrorInterface { + return new utils.Interface(_abi) as StdErrorInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): StdError { + return new Contract(address, _abi, signerOrProvider) as StdError; + } +} diff --git a/typechain-types/factories/forge-std/StdError.sol/index.ts b/typechain-types/factories/forge-std/StdError.sol/index.ts new file mode 100644 index 00000000..5c898ac1 --- /dev/null +++ b/typechain-types/factories/forge-std/StdError.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { StdError__factory } from "./StdError__factory"; diff --git a/typechain-types/factories/forge-std/StdInvariant__factory.ts b/typechain-types/factories/forge-std/StdInvariant__factory.ts new file mode 100644 index 00000000..555a0609 --- /dev/null +++ b/typechain-types/factories/forge-std/StdInvariant__factory.ts @@ -0,0 +1,204 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + StdInvariant, + StdInvariantInterface, +} from "../../forge-std/StdInvariant"; + +const _abi = [ + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class StdInvariant__factory { + static readonly abi = _abi; + static createInterface(): StdInvariantInterface { + return new utils.Interface(_abi) as StdInvariantInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): StdInvariant { + return new Contract(address, _abi, signerOrProvider) as StdInvariant; + } +} diff --git a/typechain-types/factories/forge-std/StdStorage.sol/StdStorageSafe__factory.ts b/typechain-types/factories/forge-std/StdStorage.sol/StdStorageSafe__factory.ts new file mode 100644 index 00000000..8abad169 --- /dev/null +++ b/typechain-types/factories/forge-std/StdStorage.sol/StdStorageSafe__factory.ts @@ -0,0 +1,113 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + StdStorageSafe, + StdStorageSafeInterface, +} from "../../../forge-std/StdStorage.sol/StdStorageSafe"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "who", + type: "address", + }, + { + indexed: false, + internalType: "bytes4", + name: "fsig", + type: "bytes4", + }, + { + indexed: false, + internalType: "bytes32", + name: "keysHash", + type: "bytes32", + }, + { + indexed: false, + internalType: "uint256", + name: "slot", + type: "uint256", + }, + ], + name: "SlotFound", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "who", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "slot", + type: "uint256", + }, + ], + name: "WARNING_UninitedSlot", + type: "event", + }, +] as const; + +const _bytecode = + "0x60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220d00bd3f77bc95c5f63c719093a6d31da7bdf9c8d48a9ab8306cc99545a0bf89664736f6c63430008070033"; + +type StdStorageSafeConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: StdStorageSafeConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class StdStorageSafe__factory extends ContractFactory { + constructor(...args: StdStorageSafeConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): StdStorageSafe { + return super.attach(address) as StdStorageSafe; + } + override connect(signer: Signer): StdStorageSafe__factory { + return super.connect(signer) as StdStorageSafe__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): StdStorageSafeInterface { + return new utils.Interface(_abi) as StdStorageSafeInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): StdStorageSafe { + return new Contract(address, _abi, signerOrProvider) as StdStorageSafe; + } +} diff --git a/typechain-types/factories/forge-std/StdStorage.sol/index.ts b/typechain-types/factories/forge-std/StdStorage.sol/index.ts new file mode 100644 index 00000000..4f4de1e2 --- /dev/null +++ b/typechain-types/factories/forge-std/StdStorage.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { StdStorageSafe__factory } from "./StdStorageSafe__factory"; diff --git a/typechain-types/factories/forge-std/Test__factory.ts b/typechain-types/factories/forge-std/Test__factory.ts new file mode 100644 index 00000000..d9624aae --- /dev/null +++ b/typechain-types/factories/forge-std/Test__factory.ts @@ -0,0 +1,588 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { Test, TestInterface } from "../../forge-std/Test"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "IS_TEST", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class Test__factory { + static readonly abi = _abi; + static createInterface(): TestInterface { + return new utils.Interface(_abi) as TestInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Test { + return new Contract(address, _abi, signerOrProvider) as Test; + } +} diff --git a/typechain-types/factories/forge-std/Vm.sol/VmSafe__factory.ts b/typechain-types/factories/forge-std/Vm.sol/VmSafe__factory.ts new file mode 100644 index 00000000..ec546568 --- /dev/null +++ b/typechain-types/factories/forge-std/Vm.sol/VmSafe__factory.ts @@ -0,0 +1,7315 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { VmSafe, VmSafeInterface } from "../../../forge-std/Vm.sol/VmSafe"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "accesses", + outputs: [ + { + internalType: "bytes32[]", + name: "readSlots", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "writeSlots", + type: "bytes32[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "addr", + outputs: [ + { + internalType: "address", + name: "keyAddr", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertFalse", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assertFalse", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assertTrue", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertTrue", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assume", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "char", + type: "string", + }, + ], + name: "breakpoint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "char", + type: "string", + }, + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "breakpoint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + ], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "closeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "salt", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "initCodeHash", + type: "bytes32", + }, + ], + name: "computeCreate2Address", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "salt", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "initCodeHash", + type: "bytes32", + }, + { + internalType: "address", + name: "deployer", + type: "address", + }, + ], + name: "computeCreate2Address", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "deployer", + type: "address", + }, + { + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + ], + name: "computeCreateAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "from", + type: "string", + }, + { + internalType: "string", + name: "to", + type: "string", + }, + ], + name: "copyFile", + outputs: [ + { + internalType: "uint64", + name: "copied", + type: "uint64", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bool", + name: "recursive", + type: "bool", + }, + ], + name: "createDir", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "walletLabel", + type: "string", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "string", + name: "walletLabel", + type: "string", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "string", + name: "derivationPath", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + { + internalType: "string", + name: "language", + type: "string", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + { + internalType: "string", + name: "language", + type: "string", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "string", + name: "derivationPath", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "ensNamehash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envAddress", + outputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envAddress", + outputs: [ + { + internalType: "address[]", + name: "value", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBool", + outputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBool", + outputs: [ + { + internalType: "bool[]", + name: "value", + type: "bool[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBytes", + outputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBytes", + outputs: [ + { + internalType: "bytes[]", + name: "value", + type: "bytes[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBytes32", + outputs: [ + { + internalType: "bytes32[]", + name: "value", + type: "bytes32[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBytes32", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envExists", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envInt", + outputs: [ + { + internalType: "int256[]", + name: "value", + type: "int256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envInt", + outputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bytes32[]", + name: "defaultValue", + type: "bytes32[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes32[]", + name: "value", + type: "bytes32[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "int256[]", + name: "defaultValue", + type: "int256[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "int256[]", + name: "value", + type: "int256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bool", + name: "defaultValue", + type: "bool", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "address", + name: "defaultValue", + type: "address", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "uint256", + name: "defaultValue", + type: "uint256", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bytes[]", + name: "defaultValue", + type: "bytes[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes[]", + name: "value", + type: "bytes[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "uint256[]", + name: "defaultValue", + type: "uint256[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "uint256[]", + name: "value", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "string[]", + name: "defaultValue", + type: "string[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "string[]", + name: "value", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bytes", + name: "defaultValue", + type: "bytes", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bytes32", + name: "defaultValue", + type: "bytes32", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "int256", + name: "defaultValue", + type: "int256", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "address[]", + name: "defaultValue", + type: "address[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "address[]", + name: "value", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "defaultValue", + type: "string", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "string", + name: "value", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bool[]", + name: "defaultValue", + type: "bool[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bool[]", + name: "value", + type: "bool[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envString", + outputs: [ + { + internalType: "string[]", + name: "value", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envString", + outputs: [ + { + internalType: "string", + name: "value", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envUint", + outputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envUint", + outputs: [ + { + internalType: "uint256[]", + name: "value", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "fromBlock", + type: "uint256", + }, + { + internalType: "uint256", + name: "toBlock", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + ], + name: "eth_getLogs", + outputs: [ + { + components: [ + { + internalType: "address", + name: "emitter", + type: "address", + }, + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + { + internalType: "uint64", + name: "blockNumber", + type: "uint64", + }, + { + internalType: "bytes32", + name: "transactionHash", + type: "bytes32", + }, + { + internalType: "uint64", + name: "transactionIndex", + type: "uint64", + }, + { + internalType: "uint256", + name: "logIndex", + type: "uint256", + }, + { + internalType: "bool", + name: "removed", + type: "bool", + }, + ], + internalType: "struct VmSafe.EthGetLogs[]", + name: "logs", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "exists", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "commandInput", + type: "string[]", + }, + ], + name: "ffi", + outputs: [ + { + internalType: "bytes", + name: "result", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "fsMetadata", + outputs: [ + { + components: [ + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + { + internalType: "uint256", + name: "length", + type: "uint256", + }, + { + internalType: "bool", + name: "readOnly", + type: "bool", + }, + { + internalType: "uint256", + name: "modified", + type: "uint256", + }, + { + internalType: "uint256", + name: "accessed", + type: "uint256", + }, + { + internalType: "uint256", + name: "created", + type: "uint256", + }, + ], + internalType: "struct VmSafe.FsMetadata", + name: "metadata", + type: "tuple", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlobBaseFee", + outputs: [ + { + internalType: "uint256", + name: "blobBaseFee", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlockNumber", + outputs: [ + { + internalType: "uint256", + name: "height", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlockTimestamp", + outputs: [ + { + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "artifactPath", + type: "string", + }, + ], + name: "getCode", + outputs: [ + { + internalType: "bytes", + name: "creationBytecode", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "artifactPath", + type: "string", + }, + ], + name: "getDeployedCode", + outputs: [ + { + internalType: "bytes", + name: "runtimeBytecode", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "getLabel", + outputs: [ + { + internalType: "string", + name: "currentLabel", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "elementSlot", + type: "bytes32", + }, + ], + name: "getMappingKeyAndParentOf", + outputs: [ + { + internalType: "bool", + name: "found", + type: "bool", + }, + { + internalType: "bytes32", + name: "key", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "parent", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "mappingSlot", + type: "bytes32", + }, + ], + name: "getMappingLength", + outputs: [ + { + internalType: "uint256", + name: "length", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "mappingSlot", + type: "bytes32", + }, + { + internalType: "uint256", + name: "idx", + type: "uint256", + }, + ], + name: "getMappingSlotAt", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "getNonce", + outputs: [ + { + internalType: "uint64", + name: "nonce", + type: "uint64", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + name: "getNonce", + outputs: [ + { + internalType: "uint64", + name: "nonce", + type: "uint64", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getRecordedLogs", + outputs: [ + { + components: [ + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "address", + name: "emitter", + type: "address", + }, + ], + internalType: "struct VmSafe.Log[]", + name: "logs", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "indexOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "enum VmSafe.ForgeContext", + name: "context", + type: "uint8", + }, + ], + name: "isContext", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "isDir", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "isFile", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExists", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExistsJson", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExistsToml", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "string", + name: "newLabel", + type: "string", + }, + ], + name: "label", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "lastCallGas", + outputs: [ + { + components: [ + { + internalType: "uint64", + name: "gasLimit", + type: "uint64", + }, + { + internalType: "uint64", + name: "gasTotalUsed", + type: "uint64", + }, + { + internalType: "uint64", + name: "gasMemoryUsed", + type: "uint64", + }, + { + internalType: "int64", + name: "gasRefunded", + type: "int64", + }, + { + internalType: "uint64", + name: "gasRemaining", + type: "uint64", + }, + ], + internalType: "struct VmSafe.Gas", + name: "gas", + type: "tuple", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "slot", + type: "bytes32", + }, + ], + name: "load", + outputs: [ + { + internalType: "bytes32", + name: "data", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseAddress", + outputs: [ + { + internalType: "address", + name: "parsedValue", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBool", + outputs: [ + { + internalType: "bool", + name: "parsedValue", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBytes", + outputs: [ + { + internalType: "bytes", + name: "parsedValue", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBytes32", + outputs: [ + { + internalType: "bytes32", + name: "parsedValue", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseInt", + outputs: [ + { + internalType: "int256", + name: "parsedValue", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + name: "parseJson", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJson", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonAddressArray", + outputs: [ + { + internalType: "address[]", + name: "", + type: "address[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBool", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBoolArray", + outputs: [ + { + internalType: "bool[]", + name: "", + type: "bool[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes32", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes32Array", + outputs: [ + { + internalType: "bytes32[]", + name: "", + type: "bytes32[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytesArray", + outputs: [ + { + internalType: "bytes[]", + name: "", + type: "bytes[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonInt", + outputs: [ + { + internalType: "int256", + name: "", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonIntArray", + outputs: [ + { + internalType: "int256[]", + name: "", + type: "int256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonKeys", + outputs: [ + { + internalType: "string[]", + name: "keys", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonString", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonStringArray", + outputs: [ + { + internalType: "string[]", + name: "", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonUintArray", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseToml", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + ], + name: "parseToml", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlAddressArray", + outputs: [ + { + internalType: "address[]", + name: "", + type: "address[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBool", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBoolArray", + outputs: [ + { + internalType: "bool[]", + name: "", + type: "bool[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes32", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes32Array", + outputs: [ + { + internalType: "bytes32[]", + name: "", + type: "bytes32[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytesArray", + outputs: [ + { + internalType: "bytes[]", + name: "", + type: "bytes[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlInt", + outputs: [ + { + internalType: "int256", + name: "", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlIntArray", + outputs: [ + { + internalType: "int256[]", + name: "", + type: "int256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlKeys", + outputs: [ + { + internalType: "string[]", + name: "keys", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlString", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlStringArray", + outputs: [ + { + internalType: "string[]", + name: "", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlUintArray", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseUint", + outputs: [ + { + internalType: "uint256", + name: "parsedValue", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "pauseGasMetering", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "projectRoot", + outputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "prompt", + outputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptSecret", + outputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptSecretUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "randomAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "randomUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "min", + type: "uint256", + }, + { + internalType: "uint256", + name: "max", + type: "uint256", + }, + ], + name: "randomUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "maxDepth", + type: "uint64", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "maxDepth", + type: "uint64", + }, + { + internalType: "bool", + name: "followLinks", + type: "bool", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readFile", + outputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readFileBinary", + outputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readLine", + outputs: [ + { + internalType: "string", + name: "line", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "linkPath", + type: "string", + }, + ], + name: "readLink", + outputs: [ + { + internalType: "string", + name: "targetPath", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "record", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "recordLogs", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "rememberKey", + outputs: [ + { + internalType: "address", + name: "keyAddr", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bool", + name: "recursive", + type: "bool", + }, + ], + name: "removeDir", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "removeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "from", + type: "string", + }, + { + internalType: "string", + name: "to", + type: "string", + }, + ], + name: "replace", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "resumeGasMetering", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "method", + type: "string", + }, + { + internalType: "string", + name: "params", + type: "string", + }, + ], + name: "rpc", + outputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "rpcAlias", + type: "string", + }, + ], + name: "rpcUrl", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rpcUrlStructs", + outputs: [ + { + components: [ + { + internalType: "string", + name: "key", + type: "string", + }, + { + internalType: "string", + name: "url", + type: "string", + }, + ], + internalType: "struct VmSafe.Rpc[]", + name: "urls", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rpcUrls", + outputs: [ + { + internalType: "string[2][]", + name: "urls", + type: "string[2][]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "address[]", + name: "values", + type: "address[]", + }, + ], + name: "serializeAddress", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "address", + name: "value", + type: "address", + }, + ], + name: "serializeAddress", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bool[]", + name: "values", + type: "bool[]", + }, + ], + name: "serializeBool", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "serializeBool", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes[]", + name: "values", + type: "bytes[]", + }, + ], + name: "serializeBytes", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + name: "serializeBytes", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes32[]", + name: "values", + type: "bytes32[]", + }, + ], + name: "serializeBytes32", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + name: "serializeBytes32", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + name: "serializeInt", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "int256[]", + name: "values", + type: "int256[]", + }, + ], + name: "serializeInt", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "serializeJson", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "string[]", + name: "values", + type: "string[]", + }, + ], + name: "serializeString", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "serializeString", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "serializeUint", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256[]", + name: "values", + type: "uint256[]", + }, + ], + name: "serializeUint", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "serializeUintToHex", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "setEnv", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "signP256", + outputs: [ + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "duration", + type: "uint256", + }, + ], + name: "sleep", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "delimiter", + type: "string", + }, + ], + name: "split", + outputs: [ + { + internalType: "string[]", + name: "outputs", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + ], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "startMappingRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "startStateDiffRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopAndReturnStateDiff", + outputs: [ + { + components: [ + { + components: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + { + internalType: "uint256", + name: "chainId", + type: "uint256", + }, + ], + internalType: "struct VmSafe.ChainInfo", + name: "chainInfo", + type: "tuple", + }, + { + internalType: "enum VmSafe.AccountAccessKind", + name: "kind", + type: "uint8", + }, + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "address", + name: "accessor", + type: "address", + }, + { + internalType: "bool", + name: "initialized", + type: "bool", + }, + { + internalType: "uint256", + name: "oldBalance", + type: "uint256", + }, + { + internalType: "uint256", + name: "newBalance", + type: "uint256", + }, + { + internalType: "bytes", + name: "deployedCode", + type: "bytes", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bool", + name: "reverted", + type: "bool", + }, + { + components: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "bytes32", + name: "slot", + type: "bytes32", + }, + { + internalType: "bool", + name: "isWrite", + type: "bool", + }, + { + internalType: "bytes32", + name: "previousValue", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "newValue", + type: "bytes32", + }, + { + internalType: "bool", + name: "reverted", + type: "bool", + }, + ], + internalType: "struct VmSafe.StorageAccess[]", + name: "storageAccesses", + type: "tuple[]", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + ], + internalType: "struct VmSafe.AccountAccess[]", + name: "accountAccesses", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopMappingRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "toBase64", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "toBase64", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "toBase64URL", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "toBase64URL", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "toLowercase", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "toUppercase", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "trim", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "commandInput", + type: "string[]", + }, + ], + name: "tryFfi", + outputs: [ + { + components: [ + { + internalType: "int32", + name: "exitCode", + type: "int32", + }, + { + internalType: "bytes", + name: "stdout", + type: "bytes", + }, + { + internalType: "bytes", + name: "stderr", + type: "bytes", + }, + ], + internalType: "struct VmSafe.FfiResult", + name: "result", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "unixTime", + outputs: [ + { + internalType: "uint256", + name: "milliseconds", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "writeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "writeFileBinary", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + ], + name: "writeJson", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "writeJson", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "writeLine", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + ], + name: "writeToml", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "writeToml", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class VmSafe__factory { + static readonly abi = _abi; + static createInterface(): VmSafeInterface { + return new utils.Interface(_abi) as VmSafeInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): VmSafe { + return new Contract(address, _abi, signerOrProvider) as VmSafe; + } +} diff --git a/typechain-types/factories/forge-std/Vm.sol/Vm__factory.ts b/typechain-types/factories/forge-std/Vm.sol/Vm__factory.ts new file mode 100644 index 00000000..5942aaef --- /dev/null +++ b/typechain-types/factories/forge-std/Vm.sol/Vm__factory.ts @@ -0,0 +1,8645 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { Vm, VmInterface } from "../../../forge-std/Vm.sol/Vm"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "accesses", + outputs: [ + { + internalType: "bytes32[]", + name: "readSlots", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "writeSlots", + type: "bytes32[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "activeFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "addr", + outputs: [ + { + internalType: "address", + name: "keyAddr", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "allowCheatcodes", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbs", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqAbsDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + ], + name: "assertApproxEqRel", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "maxPercentDelta", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertApproxEqRelDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertFalse", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assertFalse", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertGtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLe", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLeDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertLt", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertLtDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "left", + type: "bool", + }, + { + internalType: "bool", + name: "right", + type: "bool", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool[]", + name: "left", + type: "bool[]", + }, + { + internalType: "bool[]", + name: "right", + type: "bool[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "left", + type: "address[]", + }, + { + internalType: "address[]", + name: "right", + type: "address[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "left", + type: "string", + }, + { + internalType: "string", + name: "right", + type: "string", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "left", + type: "bytes", + }, + { + internalType: "bytes", + name: "right", + type: "bytes", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256[]", + name: "left", + type: "uint256[]", + }, + { + internalType: "uint256[]", + name: "right", + type: "uint256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "left", + type: "address", + }, + { + internalType: "address", + name: "right", + type: "address", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "left", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "right", + type: "bytes32", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "left", + type: "bytes32[]", + }, + { + internalType: "bytes32[]", + name: "right", + type: "bytes32[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "left", + type: "string[]", + }, + { + internalType: "string[]", + name: "right", + type: "string[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256[]", + name: "left", + type: "int256[]", + }, + { + internalType: "int256[]", + name: "right", + type: "int256[]", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes[]", + name: "left", + type: "bytes[]", + }, + { + internalType: "bytes[]", + name: "right", + type: "bytes[]", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + ], + name: "assertNotEq", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "left", + type: "int256", + }, + { + internalType: "int256", + name: "right", + type: "int256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "left", + type: "uint256", + }, + { + internalType: "uint256", + name: "right", + type: "uint256", + }, + { + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertNotEqDecimal", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assertTrue", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + { + internalType: "string", + name: "error", + type: "string", + }, + ], + name: "assertTrue", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "condition", + type: "bool", + }, + ], + name: "assume", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newBlobBaseFee", + type: "uint256", + }, + ], + name: "blobBaseFee", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32[]", + name: "hashes", + type: "bytes32[]", + }, + ], + name: "blobhashes", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "char", + type: "string", + }, + ], + name: "breakpoint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "char", + type: "string", + }, + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "breakpoint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + ], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "broadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newChainId", + type: "uint256", + }, + ], + name: "chainId", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "clearMockedCalls", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "closeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "newCoinbase", + type: "address", + }, + ], + name: "coinbase", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "salt", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "initCodeHash", + type: "bytes32", + }, + ], + name: "computeCreate2Address", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "salt", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "initCodeHash", + type: "bytes32", + }, + { + internalType: "address", + name: "deployer", + type: "address", + }, + ], + name: "computeCreate2Address", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "deployer", + type: "address", + }, + { + internalType: "uint256", + name: "nonce", + type: "uint256", + }, + ], + name: "computeCreateAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "from", + type: "string", + }, + { + internalType: "string", + name: "to", + type: "string", + }, + ], + name: "copyFile", + outputs: [ + { + internalType: "uint64", + name: "copied", + type: "uint64", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bool", + name: "recursive", + type: "bool", + }, + ], + name: "createDir", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + ], + name: "createFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + name: "createFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "createFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + name: "createSelectFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "createSelectFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "urlOrAlias", + type: "string", + }, + ], + name: "createSelectFork", + outputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "walletLabel", + type: "string", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "string", + name: "walletLabel", + type: "string", + }, + ], + name: "createWallet", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint256", + name: "newBalance", + type: "uint256", + }, + ], + name: "deal", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "snapshotId", + type: "uint256", + }, + ], + name: "deleteSnapshot", + outputs: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "deleteSnapshots", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "string", + name: "derivationPath", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + { + internalType: "string", + name: "language", + type: "string", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + { + internalType: "string", + name: "language", + type: "string", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "mnemonic", + type: "string", + }, + { + internalType: "string", + name: "derivationPath", + type: "string", + }, + { + internalType: "uint32", + name: "index", + type: "uint32", + }, + ], + name: "deriveKey", + outputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newDifficulty", + type: "uint256", + }, + ], + name: "difficulty", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "pathToStateJson", + type: "string", + }, + ], + name: "dumpState", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "ensNamehash", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envAddress", + outputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envAddress", + outputs: [ + { + internalType: "address[]", + name: "value", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBool", + outputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBool", + outputs: [ + { + internalType: "bool[]", + name: "value", + type: "bool[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBytes", + outputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBytes", + outputs: [ + { + internalType: "bytes[]", + name: "value", + type: "bytes[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envBytes32", + outputs: [ + { + internalType: "bytes32[]", + name: "value", + type: "bytes32[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envBytes32", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envExists", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envInt", + outputs: [ + { + internalType: "int256[]", + name: "value", + type: "int256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envInt", + outputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bytes32[]", + name: "defaultValue", + type: "bytes32[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes32[]", + name: "value", + type: "bytes32[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "int256[]", + name: "defaultValue", + type: "int256[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "int256[]", + name: "value", + type: "int256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bool", + name: "defaultValue", + type: "bool", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "address", + name: "defaultValue", + type: "address", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "uint256", + name: "defaultValue", + type: "uint256", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bytes[]", + name: "defaultValue", + type: "bytes[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes[]", + name: "value", + type: "bytes[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "uint256[]", + name: "defaultValue", + type: "uint256[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "uint256[]", + name: "value", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "string[]", + name: "defaultValue", + type: "string[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "string[]", + name: "value", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bytes", + name: "defaultValue", + type: "bytes", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "bytes32", + name: "defaultValue", + type: "bytes32", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "int256", + name: "defaultValue", + type: "int256", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "address[]", + name: "defaultValue", + type: "address[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "address[]", + name: "value", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "defaultValue", + type: "string", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "string", + name: "value", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + { + internalType: "bool[]", + name: "defaultValue", + type: "bool[]", + }, + ], + name: "envOr", + outputs: [ + { + internalType: "bool[]", + name: "value", + type: "bool[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envString", + outputs: [ + { + internalType: "string[]", + name: "value", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envString", + outputs: [ + { + internalType: "string", + name: "value", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + ], + name: "envUint", + outputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "delim", + type: "string", + }, + ], + name: "envUint", + outputs: [ + { + internalType: "uint256[]", + name: "value", + type: "uint256[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "newRuntimeBytecode", + type: "bytes", + }, + ], + name: "etch", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "fromBlock", + type: "uint256", + }, + { + internalType: "uint256", + name: "toBlock", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + ], + name: "eth_getLogs", + outputs: [ + { + components: [ + { + internalType: "address", + name: "emitter", + type: "address", + }, + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + { + internalType: "uint64", + name: "blockNumber", + type: "uint64", + }, + { + internalType: "bytes32", + name: "transactionHash", + type: "bytes32", + }, + { + internalType: "uint64", + name: "transactionIndex", + type: "uint64", + }, + { + internalType: "uint256", + name: "logIndex", + type: "uint256", + }, + { + internalType: "bool", + name: "removed", + type: "bool", + }, + ], + internalType: "struct VmSafe.EthGetLogs[]", + name: "logs", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "exists", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "uint64", + name: "gas", + type: "uint64", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "uint64", + name: "gas", + type: "uint64", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "uint64", + name: "count", + type: "uint64", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "uint64", + name: "count", + type: "uint64", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "uint64", + name: "count", + type: "uint64", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "expectCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "uint64", + name: "minGas", + type: "uint64", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "expectCallMinGas", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "uint64", + name: "minGas", + type: "uint64", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "uint64", + name: "count", + type: "uint64", + }, + ], + name: "expectCallMinGas", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "expectEmit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "checkTopic1", + type: "bool", + }, + { + internalType: "bool", + name: "checkTopic2", + type: "bool", + }, + { + internalType: "bool", + name: "checkTopic3", + type: "bool", + }, + { + internalType: "bool", + name: "checkData", + type: "bool", + }, + ], + name: "expectEmit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "checkTopic1", + type: "bool", + }, + { + internalType: "bool", + name: "checkTopic2", + type: "bool", + }, + { + internalType: "bool", + name: "checkTopic3", + type: "bool", + }, + { + internalType: "bool", + name: "checkData", + type: "bool", + }, + { + internalType: "address", + name: "emitter", + type: "address", + }, + ], + name: "expectEmit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "emitter", + type: "address", + }, + ], + name: "expectEmit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "revertData", + type: "bytes4", + }, + ], + name: "expectRevert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "revertData", + type: "bytes", + }, + ], + name: "expectRevert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "expectRevert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint64", + name: "min", + type: "uint64", + }, + { + internalType: "uint64", + name: "max", + type: "uint64", + }, + ], + name: "expectSafeMemory", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint64", + name: "min", + type: "uint64", + }, + { + internalType: "uint64", + name: "max", + type: "uint64", + }, + ], + name: "expectSafeMemoryCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newBasefee", + type: "uint256", + }, + ], + name: "fee", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "commandInput", + type: "string[]", + }, + ], + name: "ffi", + outputs: [ + { + internalType: "bytes", + name: "result", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "fsMetadata", + outputs: [ + { + components: [ + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + { + internalType: "uint256", + name: "length", + type: "uint256", + }, + { + internalType: "bool", + name: "readOnly", + type: "bool", + }, + { + internalType: "uint256", + name: "modified", + type: "uint256", + }, + { + internalType: "uint256", + name: "accessed", + type: "uint256", + }, + { + internalType: "uint256", + name: "created", + type: "uint256", + }, + ], + internalType: "struct VmSafe.FsMetadata", + name: "metadata", + type: "tuple", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlobBaseFee", + outputs: [ + { + internalType: "uint256", + name: "blobBaseFee", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlobhashes", + outputs: [ + { + internalType: "bytes32[]", + name: "hashes", + type: "bytes32[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlockNumber", + outputs: [ + { + internalType: "uint256", + name: "height", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlockTimestamp", + outputs: [ + { + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "artifactPath", + type: "string", + }, + ], + name: "getCode", + outputs: [ + { + internalType: "bytes", + name: "creationBytecode", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "artifactPath", + type: "string", + }, + ], + name: "getDeployedCode", + outputs: [ + { + internalType: "bytes", + name: "runtimeBytecode", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "getLabel", + outputs: [ + { + internalType: "string", + name: "currentLabel", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "elementSlot", + type: "bytes32", + }, + ], + name: "getMappingKeyAndParentOf", + outputs: [ + { + internalType: "bool", + name: "found", + type: "bool", + }, + { + internalType: "bytes32", + name: "key", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "parent", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "mappingSlot", + type: "bytes32", + }, + ], + name: "getMappingLength", + outputs: [ + { + internalType: "uint256", + name: "length", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "mappingSlot", + type: "bytes32", + }, + { + internalType: "uint256", + name: "idx", + type: "uint256", + }, + ], + name: "getMappingSlotAt", + outputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "getNonce", + outputs: [ + { + internalType: "uint64", + name: "nonce", + type: "uint64", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + ], + name: "getNonce", + outputs: [ + { + internalType: "uint64", + name: "nonce", + type: "uint64", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "getRecordedLogs", + outputs: [ + { + components: [ + { + internalType: "bytes32[]", + name: "topics", + type: "bytes32[]", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "address", + name: "emitter", + type: "address", + }, + ], + internalType: "struct VmSafe.Log[]", + name: "logs", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "indexOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "enum VmSafe.ForgeContext", + name: "context", + type: "uint8", + }, + ], + name: "isContext", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "isDir", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "isFile", + outputs: [ + { + internalType: "bool", + name: "result", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "isPersistent", + outputs: [ + { + internalType: "bool", + name: "persistent", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExists", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExistsJson", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "keyExistsToml", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "string", + name: "newLabel", + type: "string", + }, + ], + name: "label", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "lastCallGas", + outputs: [ + { + components: [ + { + internalType: "uint64", + name: "gasLimit", + type: "uint64", + }, + { + internalType: "uint64", + name: "gasTotalUsed", + type: "uint64", + }, + { + internalType: "uint64", + name: "gasMemoryUsed", + type: "uint64", + }, + { + internalType: "int64", + name: "gasRefunded", + type: "int64", + }, + { + internalType: "uint64", + name: "gasRemaining", + type: "uint64", + }, + ], + internalType: "struct VmSafe.Gas", + name: "gas", + type: "tuple", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "slot", + type: "bytes32", + }, + ], + name: "load", + outputs: [ + { + internalType: "bytes32", + name: "data", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "pathToAllocsJson", + type: "string", + }, + ], + name: "loadAllocs", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "accounts", + type: "address[]", + }, + ], + name: "makePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account0", + type: "address", + }, + { + internalType: "address", + name: "account1", + type: "address", + }, + ], + name: "makePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "makePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account0", + type: "address", + }, + { + internalType: "address", + name: "account1", + type: "address", + }, + { + internalType: "address", + name: "account2", + type: "address", + }, + ], + name: "makePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + name: "mockCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + name: "mockCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "uint256", + name: "msgValue", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes", + name: "revertData", + type: "bytes", + }, + ], + name: "mockCallRevert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "callee", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes", + name: "revertData", + type: "bytes", + }, + ], + name: "mockCallRevert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseAddress", + outputs: [ + { + internalType: "address", + name: "parsedValue", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBool", + outputs: [ + { + internalType: "bool", + name: "parsedValue", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBytes", + outputs: [ + { + internalType: "bytes", + name: "parsedValue", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseBytes32", + outputs: [ + { + internalType: "bytes32", + name: "parsedValue", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseInt", + outputs: [ + { + internalType: "int256", + name: "parsedValue", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + name: "parseJson", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJson", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonAddressArray", + outputs: [ + { + internalType: "address[]", + name: "", + type: "address[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBool", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBoolArray", + outputs: [ + { + internalType: "bool[]", + name: "", + type: "bool[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes32", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytes32Array", + outputs: [ + { + internalType: "bytes32[]", + name: "", + type: "bytes32[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonBytesArray", + outputs: [ + { + internalType: "bytes[]", + name: "", + type: "bytes[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonInt", + outputs: [ + { + internalType: "int256", + name: "", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonIntArray", + outputs: [ + { + internalType: "int256[]", + name: "", + type: "int256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonKeys", + outputs: [ + { + internalType: "string[]", + name: "keys", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonString", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonStringArray", + outputs: [ + { + internalType: "string[]", + name: "", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseJsonUintArray", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseToml", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + ], + name: "parseToml", + outputs: [ + { + internalType: "bytes", + name: "abiEncodedData", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlAddressArray", + outputs: [ + { + internalType: "address[]", + name: "", + type: "address[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBool", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBoolArray", + outputs: [ + { + internalType: "bool[]", + name: "", + type: "bool[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes32", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytes32Array", + outputs: [ + { + internalType: "bytes32[]", + name: "", + type: "bytes32[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlBytesArray", + outputs: [ + { + internalType: "bytes[]", + name: "", + type: "bytes[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlInt", + outputs: [ + { + internalType: "int256", + name: "", + type: "int256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlIntArray", + outputs: [ + { + internalType: "int256[]", + name: "", + type: "int256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlKeys", + outputs: [ + { + internalType: "string[]", + name: "keys", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlString", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlStringArray", + outputs: [ + { + internalType: "string[]", + name: "", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "toml", + type: "string", + }, + { + internalType: "string", + name: "key", + type: "string", + }, + ], + name: "parseTomlUintArray", + outputs: [ + { + internalType: "uint256[]", + name: "", + type: "uint256[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + name: "parseUint", + outputs: [ + { + internalType: "uint256", + name: "parsedValue", + type: "uint256", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "pauseGasMetering", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "msgSender", + type: "address", + }, + { + internalType: "address", + name: "txOrigin", + type: "address", + }, + ], + name: "prank", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "msgSender", + type: "address", + }, + ], + name: "prank", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "newPrevrandao", + type: "bytes32", + }, + ], + name: "prevrandao", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newPrevrandao", + type: "uint256", + }, + ], + name: "prevrandao", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "projectRoot", + outputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "prompt", + outputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptSecret", + outputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptSecretUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "promptText", + type: "string", + }, + ], + name: "promptUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "randomAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "randomUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "min", + type: "uint256", + }, + { + internalType: "uint256", + name: "max", + type: "uint256", + }, + ], + name: "randomUint", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "readCallers", + outputs: [ + { + internalType: "enum VmSafe.CallerMode", + name: "callerMode", + type: "uint8", + }, + { + internalType: "address", + name: "msgSender", + type: "address", + }, + { + internalType: "address", + name: "txOrigin", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "maxDepth", + type: "uint64", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "maxDepth", + type: "uint64", + }, + { + internalType: "bool", + name: "followLinks", + type: "bool", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readDir", + outputs: [ + { + components: [ + { + internalType: "string", + name: "errorMessage", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + { + internalType: "bool", + name: "isDir", + type: "bool", + }, + { + internalType: "bool", + name: "isSymlink", + type: "bool", + }, + ], + internalType: "struct VmSafe.DirEntry[]", + name: "entries", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readFile", + outputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readFileBinary", + outputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "readLine", + outputs: [ + { + internalType: "string", + name: "line", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "linkPath", + type: "string", + }, + ], + name: "readLink", + outputs: [ + { + internalType: "string", + name: "targetPath", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "record", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "recordLogs", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "rememberKey", + outputs: [ + { + internalType: "address", + name: "keyAddr", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bool", + name: "recursive", + type: "bool", + }, + ], + name: "removeDir", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "removeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "from", + type: "string", + }, + { + internalType: "string", + name: "to", + type: "string", + }, + ], + name: "replace", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "resetNonce", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "resumeGasMetering", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "snapshotId", + type: "uint256", + }, + ], + name: "revertTo", + outputs: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "snapshotId", + type: "uint256", + }, + ], + name: "revertToAndDelete", + outputs: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address[]", + name: "accounts", + type: "address[]", + }, + ], + name: "revokePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "revokePersistent", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newHeight", + type: "uint256", + }, + ], + name: "roll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "rollFork", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + name: "rollFork", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + name: "rollFork", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "rollFork", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "method", + type: "string", + }, + { + internalType: "string", + name: "params", + type: "string", + }, + ], + name: "rpc", + outputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "rpcAlias", + type: "string", + }, + ], + name: "rpcUrl", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rpcUrlStructs", + outputs: [ + { + components: [ + { + internalType: "string", + name: "key", + type: "string", + }, + { + internalType: "string", + name: "url", + type: "string", + }, + ], + internalType: "struct VmSafe.Rpc[]", + name: "urls", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "rpcUrls", + outputs: [ + { + internalType: "string[2][]", + name: "urls", + type: "string[2][]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + ], + name: "selectFork", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "address[]", + name: "values", + type: "address[]", + }, + ], + name: "serializeAddress", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "address", + name: "value", + type: "address", + }, + ], + name: "serializeAddress", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bool[]", + name: "values", + type: "bool[]", + }, + ], + name: "serializeBool", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "serializeBool", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes[]", + name: "values", + type: "bytes[]", + }, + ], + name: "serializeBytes", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + name: "serializeBytes", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes32[]", + name: "values", + type: "bytes32[]", + }, + ], + name: "serializeBytes32", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + name: "serializeBytes32", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + name: "serializeInt", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "int256[]", + name: "values", + type: "int256[]", + }, + ], + name: "serializeInt", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "serializeJson", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "string[]", + name: "values", + type: "string[]", + }, + ], + name: "serializeString", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "serializeString", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "serializeUint", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256[]", + name: "values", + type: "uint256[]", + }, + ], + name: "serializeUint", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "objectKey", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "serializeUintToHex", + outputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name", + type: "string", + }, + { + internalType: "string", + name: "value", + type: "string", + }, + ], + name: "setEnv", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint64", + name: "newNonce", + type: "uint64", + }, + ], + name: "setNonce", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint64", + name: "newNonce", + type: "uint64", + }, + ], + name: "setNonceUnsafe", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "uint256", + name: "publicKeyX", + type: "uint256", + }, + { + internalType: "uint256", + name: "publicKeyY", + type: "uint256", + }, + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + internalType: "struct VmSafe.Wallet", + name: "wallet", + type: "tuple", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "sign", + outputs: [ + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + { + internalType: "bytes32", + name: "digest", + type: "bytes32", + }, + ], + name: "signP256", + outputs: [ + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "skipTest", + type: "bool", + }, + ], + name: "skip", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "duration", + type: "uint256", + }, + ], + name: "sleep", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "snapshot", + outputs: [ + { + internalType: "uint256", + name: "snapshotId", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + { + internalType: "string", + name: "delimiter", + type: "string", + }, + ], + name: "split", + outputs: [ + { + internalType: "string[]", + name: "outputs", + type: "string[]", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "signer", + type: "address", + }, + ], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "privateKey", + type: "uint256", + }, + ], + name: "startBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "startMappingRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "msgSender", + type: "address", + }, + ], + name: "startPrank", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "msgSender", + type: "address", + }, + { + internalType: "address", + name: "txOrigin", + type: "address", + }, + ], + name: "startPrank", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "startStateDiffRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopAndReturnStateDiff", + outputs: [ + { + components: [ + { + components: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + { + internalType: "uint256", + name: "chainId", + type: "uint256", + }, + ], + internalType: "struct VmSafe.ChainInfo", + name: "chainInfo", + type: "tuple", + }, + { + internalType: "enum VmSafe.AccountAccessKind", + name: "kind", + type: "uint8", + }, + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "address", + name: "accessor", + type: "address", + }, + { + internalType: "bool", + name: "initialized", + type: "bool", + }, + { + internalType: "uint256", + name: "oldBalance", + type: "uint256", + }, + { + internalType: "uint256", + name: "newBalance", + type: "uint256", + }, + { + internalType: "bytes", + name: "deployedCode", + type: "bytes", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bool", + name: "reverted", + type: "bool", + }, + { + components: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "bytes32", + name: "slot", + type: "bytes32", + }, + { + internalType: "bool", + name: "isWrite", + type: "bool", + }, + { + internalType: "bytes32", + name: "previousValue", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "newValue", + type: "bytes32", + }, + { + internalType: "bool", + name: "reverted", + type: "bool", + }, + ], + internalType: "struct VmSafe.StorageAccess[]", + name: "storageAccesses", + type: "tuple[]", + }, + { + internalType: "uint64", + name: "depth", + type: "uint64", + }, + ], + internalType: "struct VmSafe.AccountAccess[]", + name: "accountAccesses", + type: "tuple[]", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopBroadcast", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopExpectSafeMemory", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopMappingRecording", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "stopPrank", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes32", + name: "slot", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + name: "store", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "toBase64", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "toBase64", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "toBase64URL", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "toBase64URL", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "toLowercase", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "value", + type: "address", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "value", + type: "bytes", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "value", + type: "bool", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "value", + type: "int256", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "value", + type: "bytes32", + }, + ], + name: "toString", + outputs: [ + { + internalType: "string", + name: "stringifiedValue", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "toUppercase", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "forkId", + type: "uint256", + }, + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "transact", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "txHash", + type: "bytes32", + }, + ], + name: "transact", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "input", + type: "string", + }, + ], + name: "trim", + outputs: [ + { + internalType: "string", + name: "output", + type: "string", + }, + ], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string[]", + name: "commandInput", + type: "string[]", + }, + ], + name: "tryFfi", + outputs: [ + { + components: [ + { + internalType: "int32", + name: "exitCode", + type: "int32", + }, + { + internalType: "bytes", + name: "stdout", + type: "bytes", + }, + { + internalType: "bytes", + name: "stderr", + type: "bytes", + }, + ], + internalType: "struct VmSafe.FfiResult", + name: "result", + type: "tuple", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newGasPrice", + type: "uint256", + }, + ], + name: "txGasPrice", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "unixTime", + outputs: [ + { + internalType: "uint256", + name: "milliseconds", + type: "uint256", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "newTimestamp", + type: "uint256", + }, + ], + name: "warp", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "writeFile", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "writeFileBinary", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + ], + name: "writeJson", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "writeJson", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "data", + type: "string", + }, + ], + name: "writeLine", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + { + internalType: "string", + name: "valueKey", + type: "string", + }, + ], + name: "writeToml", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "json", + type: "string", + }, + { + internalType: "string", + name: "path", + type: "string", + }, + ], + name: "writeToml", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class Vm__factory { + static readonly abi = _abi; + static createInterface(): VmInterface { + return new utils.Interface(_abi) as VmInterface; + } + static connect(address: string, signerOrProvider: Signer | Provider): Vm { + return new Contract(address, _abi, signerOrProvider) as Vm; + } +} diff --git a/typechain-types/factories/forge-std/Vm.sol/index.ts b/typechain-types/factories/forge-std/Vm.sol/index.ts new file mode 100644 index 00000000..fcea6ed4 --- /dev/null +++ b/typechain-types/factories/forge-std/Vm.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { Vm__factory } from "./Vm__factory"; +export { VmSafe__factory } from "./VmSafe__factory"; diff --git a/typechain-types/factories/forge-std/index.ts b/typechain-types/factories/forge-std/index.ts new file mode 100644 index 00000000..cfff7dbd --- /dev/null +++ b/typechain-types/factories/forge-std/index.ts @@ -0,0 +1,11 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as stdErrorSol from "./StdError.sol"; +export * as stdStorageSol from "./StdStorage.sol"; +export * as vmSol from "./Vm.sol"; +export * as interfaces from "./interfaces"; +export * as mocks from "./mocks"; +export { StdAssertions__factory } from "./StdAssertions__factory"; +export { StdInvariant__factory } from "./StdInvariant__factory"; +export { Test__factory } from "./Test__factory"; diff --git a/typechain-types/factories/forge-std/interfaces/IERC165__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC165__factory.ts new file mode 100644 index 00000000..f9cd3aa8 --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC165__factory.ts @@ -0,0 +1,45 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC165, + IERC165Interface, +} from "../../../forge-std/interfaces/IERC165"; + +const _abi = [ + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceID", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class IERC165__factory { + static readonly abi = _abi; + static createInterface(): IERC165Interface { + return new utils.Interface(_abi) as IERC165Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC165 { + return new Contract(address, _abi, signerOrProvider) as IERC165; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC20__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC20__factory.ts new file mode 100644 index 00000000..41f9852d --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC20__factory.ts @@ -0,0 +1,245 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC20, + IERC20Interface, +} from "../../../forge-std/interfaces/IERC20"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IERC20__factory { + static readonly abi = _abi; + static createInterface(): IERC20Interface { + return new utils.Interface(_abi) as IERC20Interface; + } + static connect(address: string, signerOrProvider: Signer | Provider): IERC20 { + return new Contract(address, _abi, signerOrProvider) as IERC20; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Enumerable__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Enumerable__factory.ts new file mode 100644 index 00000000..2a446610 --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Enumerable__factory.ts @@ -0,0 +1,367 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC721Enumerable, + IERC721EnumerableInterface, +} from "../../../../forge-std/interfaces/IERC721.sol/IERC721Enumerable"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_approved", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_operator", + type: "address", + }, + { + indexed: false, + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "ApprovalForAll", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_to", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "_approved", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "approve", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "getApproved", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + { + internalType: "address", + name: "_operator", + type: "address", + }, + ], + name: "isApprovedForAll", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "ownerOf", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_operator", + type: "address", + }, + { + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "setApprovalForAll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceID", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_index", + type: "uint256", + }, + ], + name: "tokenByIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + { + internalType: "uint256", + name: "_index", + type: "uint256", + }, + ], + name: "tokenOfOwnerByIndex", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +export class IERC721Enumerable__factory { + static readonly abi = _abi; + static createInterface(): IERC721EnumerableInterface { + return new utils.Interface(_abi) as IERC721EnumerableInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC721Enumerable { + return new Contract(address, _abi, signerOrProvider) as IERC721Enumerable; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Metadata__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Metadata__factory.ts new file mode 100644 index 00000000..6a62b2da --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721Metadata__factory.ts @@ -0,0 +1,356 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC721Metadata, + IERC721MetadataInterface, +} from "../../../../forge-std/interfaces/IERC721.sol/IERC721Metadata"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_approved", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_operator", + type: "address", + }, + { + indexed: false, + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "ApprovalForAll", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_to", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "_approved", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "approve", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "getApproved", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + { + internalType: "address", + name: "_operator", + type: "address", + }, + ], + name: "isApprovedForAll", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "_name", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "ownerOf", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_operator", + type: "address", + }, + { + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "setApprovalForAll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceID", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "_symbol", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "tokenURI", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +export class IERC721Metadata__factory { + static readonly abi = _abi; + static createInterface(): IERC721MetadataInterface { + return new utils.Interface(_abi) as IERC721MetadataInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC721Metadata { + return new Contract(address, _abi, signerOrProvider) as IERC721Metadata; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver__factory.ts new file mode 100644 index 00000000..6f25120a --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver__factory.ts @@ -0,0 +1,64 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC721TokenReceiver, + IERC721TokenReceiverInterface, +} from "../../../../forge-std/interfaces/IERC721.sol/IERC721TokenReceiver"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_operator", + type: "address", + }, + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "_data", + type: "bytes", + }, + ], + name: "onERC721Received", + outputs: [ + { + internalType: "bytes4", + name: "", + type: "bytes4", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IERC721TokenReceiver__factory { + static readonly abi = _abi; + static createInterface(): IERC721TokenReceiverInterface { + return new utils.Interface(_abi) as IERC721TokenReceiverInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC721TokenReceiver { + return new Contract( + address, + _abi, + signerOrProvider + ) as IERC721TokenReceiver; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721__factory.ts b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721__factory.ts new file mode 100644 index 00000000..ea8578bc --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC721.sol/IERC721__factory.ts @@ -0,0 +1,311 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IERC721, + IERC721Interface, +} from "../../../../forge-std/interfaces/IERC721.sol/IERC721"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_approved", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_operator", + type: "address", + }, + { + indexed: false, + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "ApprovalForAll", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_to", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "_approved", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "approve", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "getApproved", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_owner", + type: "address", + }, + { + internalType: "address", + name: "_operator", + type: "address", + }, + ], + name: "isApprovedForAll", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "ownerOf", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_operator", + type: "address", + }, + { + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "setApprovalForAll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceID", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "_from", + type: "address", + }, + { + internalType: "address", + name: "_to", + type: "address", + }, + { + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +export class IERC721__factory { + static readonly abi = _abi; + static createInterface(): IERC721Interface { + return new utils.Interface(_abi) as IERC721Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IERC721 { + return new Contract(address, _abi, signerOrProvider) as IERC721; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/IERC721.sol/index.ts b/typechain-types/factories/forge-std/interfaces/IERC721.sol/index.ts new file mode 100644 index 00000000..93147b21 --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IERC721.sol/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IERC721__factory } from "./IERC721__factory"; +export { IERC721Enumerable__factory } from "./IERC721Enumerable__factory"; +export { IERC721Metadata__factory } from "./IERC721Metadata__factory"; +export { IERC721TokenReceiver__factory } from "./IERC721TokenReceiver__factory"; diff --git a/typechain-types/factories/forge-std/interfaces/IMulticall3__factory.ts b/typechain-types/factories/forge-std/interfaces/IMulticall3__factory.ts new file mode 100644 index 00000000..66051d4f --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/IMulticall3__factory.ts @@ -0,0 +1,464 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IMulticall3, + IMulticall3Interface, +} from "../../../forge-std/interfaces/IMulticall3"; + +const _abi = [ + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "aggregate", + outputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + { + internalType: "bytes[]", + name: "returnData", + type: "bytes[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bool", + name: "allowFailure", + type: "bool", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call3[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "aggregate3", + outputs: [ + { + components: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Result[]", + name: "returnData", + type: "tuple[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bool", + name: "allowFailure", + type: "bool", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call3Value[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "aggregate3Value", + outputs: [ + { + components: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Result[]", + name: "returnData", + type: "tuple[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "blockAndAggregate", + outputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + { + components: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Result[]", + name: "returnData", + type: "tuple[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [], + name: "getBasefee", + outputs: [ + { + internalType: "uint256", + name: "basefee", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + name: "getBlockHash", + outputs: [ + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getBlockNumber", + outputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getChainId", + outputs: [ + { + internalType: "uint256", + name: "chainid", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getCurrentBlockCoinbase", + outputs: [ + { + internalType: "address", + name: "coinbase", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getCurrentBlockDifficulty", + outputs: [ + { + internalType: "uint256", + name: "difficulty", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getCurrentBlockGasLimit", + outputs: [ + { + internalType: "uint256", + name: "gaslimit", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getCurrentBlockTimestamp", + outputs: [ + { + internalType: "uint256", + name: "timestamp", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + ], + name: "getEthBalance", + outputs: [ + { + internalType: "uint256", + name: "balance", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "getLastBlockHash", + outputs: [ + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "requireSuccess", + type: "bool", + }, + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "tryAggregate", + outputs: [ + { + components: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Result[]", + name: "returnData", + type: "tuple[]", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "bool", + name: "requireSuccess", + type: "bool", + }, + { + components: [ + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "callData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Call[]", + name: "calls", + type: "tuple[]", + }, + ], + name: "tryBlockAndAggregate", + outputs: [ + { + internalType: "uint256", + name: "blockNumber", + type: "uint256", + }, + { + internalType: "bytes32", + name: "blockHash", + type: "bytes32", + }, + { + components: [ + { + internalType: "bool", + name: "success", + type: "bool", + }, + { + internalType: "bytes", + name: "returnData", + type: "bytes", + }, + ], + internalType: "struct IMulticall3.Result[]", + name: "returnData", + type: "tuple[]", + }, + ], + stateMutability: "payable", + type: "function", + }, +] as const; + +export class IMulticall3__factory { + static readonly abi = _abi; + static createInterface(): IMulticall3Interface { + return new utils.Interface(_abi) as IMulticall3Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IMulticall3 { + return new Contract(address, _abi, signerOrProvider) as IMulticall3; + } +} diff --git a/typechain-types/factories/forge-std/interfaces/index.ts b/typechain-types/factories/forge-std/interfaces/index.ts new file mode 100644 index 00000000..174beea6 --- /dev/null +++ b/typechain-types/factories/forge-std/interfaces/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as ierc721Sol from "./IERC721.sol"; +export { IERC165__factory } from "./IERC165__factory"; +export { IERC20__factory } from "./IERC20__factory"; +export { IMulticall3__factory } from "./IMulticall3__factory"; diff --git a/typechain-types/factories/forge-std/mocks/MockERC20__factory.ts b/typechain-types/factories/forge-std/mocks/MockERC20__factory.ts new file mode 100644 index 00000000..c6cedc7c --- /dev/null +++ b/typechain-types/factories/forge-std/mocks/MockERC20__factory.ts @@ -0,0 +1,383 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + MockERC20, + MockERC20Interface, +} from "../../../forge-std/mocks/MockERC20"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [], + name: "DOMAIN_SEPARATOR", + outputs: [ + { + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name_", + type: "string", + }, + { + internalType: "string", + name: "symbol_", + type: "string", + }, + { + internalType: "uint8", + name: "decimals_", + type: "uint8", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + name: "nonces", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "uint256", + name: "deadline", + type: "uint256", + }, + { + internalType: "uint8", + name: "v", + type: "uint8", + }, + { + internalType: "bytes32", + name: "r", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "s", + type: "bytes32", + }, + ], + name: "permit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type MockERC20ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: MockERC20ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class MockERC20__factory extends ContractFactory { + constructor(...args: MockERC20ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): MockERC20 { + return super.attach(address) as MockERC20; + } + override connect(signer: Signer): MockERC20__factory { + return super.connect(signer) as MockERC20__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): MockERC20Interface { + return new utils.Interface(_abi) as MockERC20Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): MockERC20 { + return new Contract(address, _abi, signerOrProvider) as MockERC20; + } +} diff --git a/typechain-types/factories/forge-std/mocks/MockERC721__factory.ts b/typechain-types/factories/forge-std/mocks/MockERC721__factory.ts new file mode 100644 index 00000000..8c286383 --- /dev/null +++ b/typechain-types/factories/forge-std/mocks/MockERC721__factory.ts @@ -0,0 +1,411 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../common"; +import type { + MockERC721, + MockERC721Interface, +} from "../../../forge-std/mocks/MockERC721"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_approved", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_operator", + type: "address", + }, + { + indexed: false, + internalType: "bool", + name: "_approved", + type: "bool", + }, + ], + name: "ApprovalForAll", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "_from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "_to", + type: "address", + }, + { + indexed: true, + internalType: "uint256", + name: "_tokenId", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "approve", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "getApproved", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "name_", + type: "string", + }, + { + internalType: "string", + name: "symbol_", + type: "string", + }, + ], + name: "initialize", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "operator", + type: "address", + }, + ], + name: "isApprovedForAll", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "ownerOf", + outputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "safeTransferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "operator", + type: "address", + }, + { + internalType: "bool", + name: "approved", + type: "bool", + }, + ], + name: "setApprovalForAll", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes4", + name: "interfaceId", + type: "bytes4", + }, + ], + name: "supportsInterface", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "tokenURI", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "id", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [], + stateMutability: "payable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type MockERC721ConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: MockERC721ConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class MockERC721__factory extends ContractFactory { + constructor(...args: MockERC721ConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): MockERC721 { + return super.attach(address) as MockERC721; + } + override connect(signer: Signer): MockERC721__factory { + return super.connect(signer) as MockERC721__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): MockERC721Interface { + return new utils.Interface(_abi) as MockERC721Interface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): MockERC721 { + return new Contract(address, _abi, signerOrProvider) as MockERC721; + } +} diff --git a/typechain-types/factories/forge-std/mocks/index.ts b/typechain-types/factories/forge-std/mocks/index.ts new file mode 100644 index 00000000..81493a9e --- /dev/null +++ b/typechain-types/factories/forge-std/mocks/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { MockERC20__factory } from "./MockERC20__factory"; +export { MockERC721__factory } from "./MockERC721__factory"; diff --git a/typechain-types/factories/index.ts b/typechain-types/factories/index.ts index 3eb87854..187b6345 100644 --- a/typechain-types/factories/index.ts +++ b/typechain-types/factories/index.ts @@ -4,3 +4,4 @@ export * as openzeppelin from "./@openzeppelin"; export * as uniswap from "./@uniswap"; export * as contracts from "./contracts"; +export * as forgeStd from "./forge-std"; diff --git a/typechain-types/forge-std/StdAssertions.ts b/typechain-types/forge-std/StdAssertions.ts new file mode 100644 index 00000000..faa5b50a --- /dev/null +++ b/typechain-types/forge-std/StdAssertions.ts @@ -0,0 +1,457 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../common"; + +export interface StdAssertionsInterface extends utils.Interface { + functions: { + "failed()": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "failed"): FunctionFragment; + + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + + events: { + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface StdAssertions extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StdAssertionsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + failed(overrides?: CallOverrides): Promise<[boolean]>; + }; + + failed(overrides?: CallOverrides): Promise; + + callStatic: { + failed(overrides?: CallOverrides): Promise; + }; + + filters: { + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + failed(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + failed(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/forge-std/StdError.sol/StdError.ts b/typechain-types/forge-std/StdError.sol/StdError.ts new file mode 100644 index 00000000..1a90c16e --- /dev/null +++ b/typechain-types/forge-std/StdError.sol/StdError.ts @@ -0,0 +1,249 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface StdErrorInterface extends utils.Interface { + functions: { + "arithmeticError()": FunctionFragment; + "assertionError()": FunctionFragment; + "divisionError()": FunctionFragment; + "encodeStorageError()": FunctionFragment; + "enumConversionError()": FunctionFragment; + "indexOOBError()": FunctionFragment; + "memOverflowError()": FunctionFragment; + "popError()": FunctionFragment; + "zeroVarError()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "arithmeticError" + | "assertionError" + | "divisionError" + | "encodeStorageError" + | "enumConversionError" + | "indexOOBError" + | "memOverflowError" + | "popError" + | "zeroVarError" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "arithmeticError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "assertionError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "divisionError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "encodeStorageError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "enumConversionError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "indexOOBError", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "memOverflowError", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "popError", values?: undefined): string; + encodeFunctionData( + functionFragment: "zeroVarError", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "arithmeticError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertionError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "divisionError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "encodeStorageError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "enumConversionError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "indexOOBError", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "memOverflowError", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "popError", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "zeroVarError", + data: BytesLike + ): Result; + + events: {}; +} + +export interface StdError extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StdErrorInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + arithmeticError(overrides?: CallOverrides): Promise<[string]>; + + assertionError(overrides?: CallOverrides): Promise<[string]>; + + divisionError(overrides?: CallOverrides): Promise<[string]>; + + encodeStorageError(overrides?: CallOverrides): Promise<[string]>; + + enumConversionError(overrides?: CallOverrides): Promise<[string]>; + + indexOOBError(overrides?: CallOverrides): Promise<[string]>; + + memOverflowError(overrides?: CallOverrides): Promise<[string]>; + + popError(overrides?: CallOverrides): Promise<[string]>; + + zeroVarError(overrides?: CallOverrides): Promise<[string]>; + }; + + arithmeticError(overrides?: CallOverrides): Promise; + + assertionError(overrides?: CallOverrides): Promise; + + divisionError(overrides?: CallOverrides): Promise; + + encodeStorageError(overrides?: CallOverrides): Promise; + + enumConversionError(overrides?: CallOverrides): Promise; + + indexOOBError(overrides?: CallOverrides): Promise; + + memOverflowError(overrides?: CallOverrides): Promise; + + popError(overrides?: CallOverrides): Promise; + + zeroVarError(overrides?: CallOverrides): Promise; + + callStatic: { + arithmeticError(overrides?: CallOverrides): Promise; + + assertionError(overrides?: CallOverrides): Promise; + + divisionError(overrides?: CallOverrides): Promise; + + encodeStorageError(overrides?: CallOverrides): Promise; + + enumConversionError(overrides?: CallOverrides): Promise; + + indexOOBError(overrides?: CallOverrides): Promise; + + memOverflowError(overrides?: CallOverrides): Promise; + + popError(overrides?: CallOverrides): Promise; + + zeroVarError(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + arithmeticError(overrides?: CallOverrides): Promise; + + assertionError(overrides?: CallOverrides): Promise; + + divisionError(overrides?: CallOverrides): Promise; + + encodeStorageError(overrides?: CallOverrides): Promise; + + enumConversionError(overrides?: CallOverrides): Promise; + + indexOOBError(overrides?: CallOverrides): Promise; + + memOverflowError(overrides?: CallOverrides): Promise; + + popError(overrides?: CallOverrides): Promise; + + zeroVarError(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + arithmeticError(overrides?: CallOverrides): Promise; + + assertionError(overrides?: CallOverrides): Promise; + + divisionError(overrides?: CallOverrides): Promise; + + encodeStorageError( + overrides?: CallOverrides + ): Promise; + + enumConversionError( + overrides?: CallOverrides + ): Promise; + + indexOOBError(overrides?: CallOverrides): Promise; + + memOverflowError(overrides?: CallOverrides): Promise; + + popError(overrides?: CallOverrides): Promise; + + zeroVarError(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/forge-std/StdError.sol/index.ts b/typechain-types/forge-std/StdError.sol/index.ts new file mode 100644 index 00000000..011e98fa --- /dev/null +++ b/typechain-types/forge-std/StdError.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { StdError } from "./StdError"; diff --git a/typechain-types/forge-std/StdInvariant.ts b/typechain-types/forge-std/StdInvariant.ts new file mode 100644 index 00000000..f104b23c --- /dev/null +++ b/typechain-types/forge-std/StdInvariant.ts @@ -0,0 +1,357 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface StdInvariantInterface extends utils.Interface { + functions: { + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + + events: {}; +} + +export interface StdInvariant extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StdInvariantInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + }; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + callStatic: { + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/forge-std/StdStorage.sol/StdStorageSafe.ts b/typechain-types/forge-std/StdStorage.sol/StdStorageSafe.ts new file mode 100644 index 00000000..d4c1eb04 --- /dev/null +++ b/typechain-types/forge-std/StdStorage.sol/StdStorageSafe.ts @@ -0,0 +1,109 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface StdStorageSafeInterface extends utils.Interface { + functions: {}; + + events: { + "SlotFound(address,bytes4,bytes32,uint256)": EventFragment; + "WARNING_UninitedSlot(address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "SlotFound"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WARNING_UninitedSlot"): EventFragment; +} + +export interface SlotFoundEventObject { + who: string; + fsig: string; + keysHash: string; + slot: BigNumber; +} +export type SlotFoundEvent = TypedEvent< + [string, string, string, BigNumber], + SlotFoundEventObject +>; + +export type SlotFoundEventFilter = TypedEventFilter; + +export interface WARNING_UninitedSlotEventObject { + who: string; + slot: BigNumber; +} +export type WARNING_UninitedSlotEvent = TypedEvent< + [string, BigNumber], + WARNING_UninitedSlotEventObject +>; + +export type WARNING_UninitedSlotEventFilter = + TypedEventFilter; + +export interface StdStorageSafe extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: StdStorageSafeInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "SlotFound(address,bytes4,bytes32,uint256)"( + who?: null, + fsig?: null, + keysHash?: null, + slot?: null + ): SlotFoundEventFilter; + SlotFound( + who?: null, + fsig?: null, + keysHash?: null, + slot?: null + ): SlotFoundEventFilter; + + "WARNING_UninitedSlot(address,uint256)"( + who?: null, + slot?: null + ): WARNING_UninitedSlotEventFilter; + WARNING_UninitedSlot( + who?: null, + slot?: null + ): WARNING_UninitedSlotEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/forge-std/StdStorage.sol/index.ts b/typechain-types/forge-std/StdStorage.sol/index.ts new file mode 100644 index 00000000..8a3fb579 --- /dev/null +++ b/typechain-types/forge-std/StdStorage.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { StdStorageSafe } from "./StdStorageSafe"; diff --git a/typechain-types/forge-std/Test.ts b/typechain-types/forge-std/Test.ts new file mode 100644 index 00000000..b1a7e754 --- /dev/null +++ b/typechain-types/forge-std/Test.ts @@ -0,0 +1,760 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface TestInterface extends utils.Interface { + functions: { + "IS_TEST()": FunctionFragment; + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "failed()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "IS_TEST" + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "failed" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string; + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + + events: { + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface Test extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: TestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + IS_TEST(overrides?: CallOverrides): Promise<[boolean]>; + + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + failed(overrides?: CallOverrides): Promise<[boolean]>; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + }; + + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + callStatic: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; + + filters: { + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/forge-std/Vm.sol/Vm.ts b/typechain-types/forge-std/Vm.sol/Vm.ts new file mode 100644 index 00000000..a7b56645 --- /dev/null +++ b/typechain-types/forge-std/Vm.sol/Vm.ts @@ -0,0 +1,16207 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export declare namespace VmSafe { + export type WalletStruct = { + addr: PromiseOrValue; + publicKeyX: PromiseOrValue; + publicKeyY: PromiseOrValue; + privateKey: PromiseOrValue; + }; + + export type WalletStructOutput = [string, BigNumber, BigNumber, BigNumber] & { + addr: string; + publicKeyX: BigNumber; + publicKeyY: BigNumber; + privateKey: BigNumber; + }; + + export type EthGetLogsStruct = { + emitter: PromiseOrValue; + topics: PromiseOrValue[]; + data: PromiseOrValue; + blockHash: PromiseOrValue; + blockNumber: PromiseOrValue; + transactionHash: PromiseOrValue; + transactionIndex: PromiseOrValue; + logIndex: PromiseOrValue; + removed: PromiseOrValue; + }; + + export type EthGetLogsStructOutput = [ + string, + string[], + string, + string, + BigNumber, + string, + BigNumber, + BigNumber, + boolean + ] & { + emitter: string; + topics: string[]; + data: string; + blockHash: string; + blockNumber: BigNumber; + transactionHash: string; + transactionIndex: BigNumber; + logIndex: BigNumber; + removed: boolean; + }; + + export type FsMetadataStruct = { + isDir: PromiseOrValue; + isSymlink: PromiseOrValue; + length: PromiseOrValue; + readOnly: PromiseOrValue; + modified: PromiseOrValue; + accessed: PromiseOrValue; + created: PromiseOrValue; + }; + + export type FsMetadataStructOutput = [ + boolean, + boolean, + BigNumber, + boolean, + BigNumber, + BigNumber, + BigNumber + ] & { + isDir: boolean; + isSymlink: boolean; + length: BigNumber; + readOnly: boolean; + modified: BigNumber; + accessed: BigNumber; + created: BigNumber; + }; + + export type LogStruct = { + topics: PromiseOrValue[]; + data: PromiseOrValue; + emitter: PromiseOrValue; + }; + + export type LogStructOutput = [string[], string, string] & { + topics: string[]; + data: string; + emitter: string; + }; + + export type GasStruct = { + gasLimit: PromiseOrValue; + gasTotalUsed: PromiseOrValue; + gasMemoryUsed: PromiseOrValue; + gasRefunded: PromiseOrValue; + gasRemaining: PromiseOrValue; + }; + + export type GasStructOutput = [ + BigNumber, + BigNumber, + BigNumber, + BigNumber, + BigNumber + ] & { + gasLimit: BigNumber; + gasTotalUsed: BigNumber; + gasMemoryUsed: BigNumber; + gasRefunded: BigNumber; + gasRemaining: BigNumber; + }; + + export type DirEntryStruct = { + errorMessage: PromiseOrValue; + path: PromiseOrValue; + depth: PromiseOrValue; + isDir: PromiseOrValue; + isSymlink: PromiseOrValue; + }; + + export type DirEntryStructOutput = [ + string, + string, + BigNumber, + boolean, + boolean + ] & { + errorMessage: string; + path: string; + depth: BigNumber; + isDir: boolean; + isSymlink: boolean; + }; + + export type RpcStruct = { + key: PromiseOrValue; + url: PromiseOrValue; + }; + + export type RpcStructOutput = [string, string] & { key: string; url: string }; + + export type ChainInfoStruct = { + forkId: PromiseOrValue; + chainId: PromiseOrValue; + }; + + export type ChainInfoStructOutput = [BigNumber, BigNumber] & { + forkId: BigNumber; + chainId: BigNumber; + }; + + export type StorageAccessStruct = { + account: PromiseOrValue; + slot: PromiseOrValue; + isWrite: PromiseOrValue; + previousValue: PromiseOrValue; + newValue: PromiseOrValue; + reverted: PromiseOrValue; + }; + + export type StorageAccessStructOutput = [ + string, + string, + boolean, + string, + string, + boolean + ] & { + account: string; + slot: string; + isWrite: boolean; + previousValue: string; + newValue: string; + reverted: boolean; + }; + + export type AccountAccessStruct = { + chainInfo: VmSafe.ChainInfoStruct; + kind: PromiseOrValue; + account: PromiseOrValue; + accessor: PromiseOrValue; + initialized: PromiseOrValue; + oldBalance: PromiseOrValue; + newBalance: PromiseOrValue; + deployedCode: PromiseOrValue; + value: PromiseOrValue; + data: PromiseOrValue; + reverted: PromiseOrValue; + storageAccesses: VmSafe.StorageAccessStruct[]; + depth: PromiseOrValue; + }; + + export type AccountAccessStructOutput = [ + VmSafe.ChainInfoStructOutput, + number, + string, + string, + boolean, + BigNumber, + BigNumber, + string, + BigNumber, + string, + boolean, + VmSafe.StorageAccessStructOutput[], + BigNumber + ] & { + chainInfo: VmSafe.ChainInfoStructOutput; + kind: number; + account: string; + accessor: string; + initialized: boolean; + oldBalance: BigNumber; + newBalance: BigNumber; + deployedCode: string; + value: BigNumber; + data: string; + reverted: boolean; + storageAccesses: VmSafe.StorageAccessStructOutput[]; + depth: BigNumber; + }; + + export type FfiResultStruct = { + exitCode: PromiseOrValue; + stdout: PromiseOrValue; + stderr: PromiseOrValue; + }; + + export type FfiResultStructOutput = [number, string, string] & { + exitCode: number; + stdout: string; + stderr: string; + }; +} + +export interface VmInterface extends utils.Interface { + functions: { + "accesses(address)": FunctionFragment; + "activeFork()": FunctionFragment; + "addr(uint256)": FunctionFragment; + "allowCheatcodes(address)": FunctionFragment; + "assertApproxEqAbs(uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbs(int256,int256,uint256)": FunctionFragment; + "assertApproxEqAbs(int256,int256,uint256,string)": FunctionFragment; + "assertApproxEqAbs(uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRel(uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRel(uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqRel(int256,int256,uint256,string)": FunctionFragment; + "assertApproxEqRel(int256,int256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)": FunctionFragment; + "assertEq(bytes32[],bytes32[])": FunctionFragment; + "assertEq(int256[],int256[],string)": FunctionFragment; + "assertEq(address,address,string)": FunctionFragment; + "assertEq(string,string,string)": FunctionFragment; + "assertEq(address[],address[])": FunctionFragment; + "assertEq(address[],address[],string)": FunctionFragment; + "assertEq(bool,bool,string)": FunctionFragment; + "assertEq(address,address)": FunctionFragment; + "assertEq(uint256[],uint256[],string)": FunctionFragment; + "assertEq(bool[],bool[])": FunctionFragment; + "assertEq(int256[],int256[])": FunctionFragment; + "assertEq(int256,int256,string)": FunctionFragment; + "assertEq(bytes32,bytes32)": FunctionFragment; + "assertEq(uint256,uint256,string)": FunctionFragment; + "assertEq(uint256[],uint256[])": FunctionFragment; + "assertEq(bytes,bytes)": FunctionFragment; + "assertEq(uint256,uint256)": FunctionFragment; + "assertEq(bytes32,bytes32,string)": FunctionFragment; + "assertEq(string[],string[])": FunctionFragment; + "assertEq(bytes32[],bytes32[],string)": FunctionFragment; + "assertEq(bytes,bytes,string)": FunctionFragment; + "assertEq(bool[],bool[],string)": FunctionFragment; + "assertEq(bytes[],bytes[])": FunctionFragment; + "assertEq(string[],string[],string)": FunctionFragment; + "assertEq(string,string)": FunctionFragment; + "assertEq(bytes[],bytes[],string)": FunctionFragment; + "assertEq(bool,bool)": FunctionFragment; + "assertEq(int256,int256)": FunctionFragment; + "assertEqDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertEqDecimal(int256,int256,uint256)": FunctionFragment; + "assertEqDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertEqDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertFalse(bool,string)": FunctionFragment; + "assertFalse(bool)": FunctionFragment; + "assertGe(int256,int256)": FunctionFragment; + "assertGe(int256,int256,string)": FunctionFragment; + "assertGe(uint256,uint256)": FunctionFragment; + "assertGe(uint256,uint256,string)": FunctionFragment; + "assertGeDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertGeDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertGeDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertGeDecimal(int256,int256,uint256)": FunctionFragment; + "assertGt(int256,int256)": FunctionFragment; + "assertGt(uint256,uint256,string)": FunctionFragment; + "assertGt(uint256,uint256)": FunctionFragment; + "assertGt(int256,int256,string)": FunctionFragment; + "assertGtDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertGtDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertGtDecimal(int256,int256,uint256)": FunctionFragment; + "assertGtDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLe(int256,int256,string)": FunctionFragment; + "assertLe(uint256,uint256)": FunctionFragment; + "assertLe(int256,int256)": FunctionFragment; + "assertLe(uint256,uint256,string)": FunctionFragment; + "assertLeDecimal(int256,int256,uint256)": FunctionFragment; + "assertLeDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertLeDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertLeDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLt(int256,int256)": FunctionFragment; + "assertLt(uint256,uint256,string)": FunctionFragment; + "assertLt(int256,int256,string)": FunctionFragment; + "assertLt(uint256,uint256)": FunctionFragment; + "assertLtDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLtDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertLtDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertLtDecimal(int256,int256,uint256)": FunctionFragment; + "assertNotEq(bytes32[],bytes32[])": FunctionFragment; + "assertNotEq(int256[],int256[])": FunctionFragment; + "assertNotEq(bool,bool,string)": FunctionFragment; + "assertNotEq(bytes[],bytes[],string)": FunctionFragment; + "assertNotEq(bool,bool)": FunctionFragment; + "assertNotEq(bool[],bool[])": FunctionFragment; + "assertNotEq(bytes,bytes)": FunctionFragment; + "assertNotEq(address[],address[])": FunctionFragment; + "assertNotEq(int256,int256,string)": FunctionFragment; + "assertNotEq(uint256[],uint256[])": FunctionFragment; + "assertNotEq(bool[],bool[],string)": FunctionFragment; + "assertNotEq(string,string)": FunctionFragment; + "assertNotEq(address[],address[],string)": FunctionFragment; + "assertNotEq(string,string,string)": FunctionFragment; + "assertNotEq(address,address,string)": FunctionFragment; + "assertNotEq(bytes32,bytes32)": FunctionFragment; + "assertNotEq(bytes,bytes,string)": FunctionFragment; + "assertNotEq(uint256,uint256,string)": FunctionFragment; + "assertNotEq(uint256[],uint256[],string)": FunctionFragment; + "assertNotEq(address,address)": FunctionFragment; + "assertNotEq(bytes32,bytes32,string)": FunctionFragment; + "assertNotEq(string[],string[],string)": FunctionFragment; + "assertNotEq(uint256,uint256)": FunctionFragment; + "assertNotEq(bytes32[],bytes32[],string)": FunctionFragment; + "assertNotEq(string[],string[])": FunctionFragment; + "assertNotEq(int256[],int256[],string)": FunctionFragment; + "assertNotEq(bytes[],bytes[])": FunctionFragment; + "assertNotEq(int256,int256)": FunctionFragment; + "assertNotEqDecimal(int256,int256,uint256)": FunctionFragment; + "assertNotEqDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertNotEqDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertNotEqDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertTrue(bool)": FunctionFragment; + "assertTrue(bool,string)": FunctionFragment; + "assume(bool)": FunctionFragment; + "blobBaseFee(uint256)": FunctionFragment; + "blobhashes(bytes32[])": FunctionFragment; + "breakpoint(string)": FunctionFragment; + "breakpoint(string,bool)": FunctionFragment; + "broadcast()": FunctionFragment; + "broadcast(address)": FunctionFragment; + "broadcast(uint256)": FunctionFragment; + "chainId(uint256)": FunctionFragment; + "clearMockedCalls()": FunctionFragment; + "closeFile(string)": FunctionFragment; + "coinbase(address)": FunctionFragment; + "computeCreate2Address(bytes32,bytes32)": FunctionFragment; + "computeCreate2Address(bytes32,bytes32,address)": FunctionFragment; + "computeCreateAddress(address,uint256)": FunctionFragment; + "copyFile(string,string)": FunctionFragment; + "createDir(string,bool)": FunctionFragment; + "createFork(string)": FunctionFragment; + "createFork(string,uint256)": FunctionFragment; + "createFork(string,bytes32)": FunctionFragment; + "createSelectFork(string,uint256)": FunctionFragment; + "createSelectFork(string,bytes32)": FunctionFragment; + "createSelectFork(string)": FunctionFragment; + "createWallet(string)": FunctionFragment; + "createWallet(uint256)": FunctionFragment; + "createWallet(uint256,string)": FunctionFragment; + "deal(address,uint256)": FunctionFragment; + "deleteSnapshot(uint256)": FunctionFragment; + "deleteSnapshots()": FunctionFragment; + "deriveKey(string,string,uint32,string)": FunctionFragment; + "deriveKey(string,uint32,string)": FunctionFragment; + "deriveKey(string,uint32)": FunctionFragment; + "deriveKey(string,string,uint32)": FunctionFragment; + "difficulty(uint256)": FunctionFragment; + "dumpState(string)": FunctionFragment; + "ensNamehash(string)": FunctionFragment; + "envAddress(string)": FunctionFragment; + "envAddress(string,string)": FunctionFragment; + "envBool(string)": FunctionFragment; + "envBool(string,string)": FunctionFragment; + "envBytes(string)": FunctionFragment; + "envBytes(string,string)": FunctionFragment; + "envBytes32(string,string)": FunctionFragment; + "envBytes32(string)": FunctionFragment; + "envExists(string)": FunctionFragment; + "envInt(string,string)": FunctionFragment; + "envInt(string)": FunctionFragment; + "envOr(string,string,bytes32[])": FunctionFragment; + "envOr(string,string,int256[])": FunctionFragment; + "envOr(string,bool)": FunctionFragment; + "envOr(string,address)": FunctionFragment; + "envOr(string,uint256)": FunctionFragment; + "envOr(string,string,bytes[])": FunctionFragment; + "envOr(string,string,uint256[])": FunctionFragment; + "envOr(string,string,string[])": FunctionFragment; + "envOr(string,bytes)": FunctionFragment; + "envOr(string,bytes32)": FunctionFragment; + "envOr(string,int256)": FunctionFragment; + "envOr(string,string,address[])": FunctionFragment; + "envOr(string,string)": FunctionFragment; + "envOr(string,string,bool[])": FunctionFragment; + "envString(string,string)": FunctionFragment; + "envString(string)": FunctionFragment; + "envUint(string)": FunctionFragment; + "envUint(string,string)": FunctionFragment; + "etch(address,bytes)": FunctionFragment; + "eth_getLogs(uint256,uint256,address,bytes32[])": FunctionFragment; + "exists(string)": FunctionFragment; + "expectCall(address,uint256,uint64,bytes)": FunctionFragment; + "expectCall(address,uint256,uint64,bytes,uint64)": FunctionFragment; + "expectCall(address,uint256,bytes,uint64)": FunctionFragment; + "expectCall(address,bytes)": FunctionFragment; + "expectCall(address,bytes,uint64)": FunctionFragment; + "expectCall(address,uint256,bytes)": FunctionFragment; + "expectCallMinGas(address,uint256,uint64,bytes)": FunctionFragment; + "expectCallMinGas(address,uint256,uint64,bytes,uint64)": FunctionFragment; + "expectEmit()": FunctionFragment; + "expectEmit(bool,bool,bool,bool)": FunctionFragment; + "expectEmit(bool,bool,bool,bool,address)": FunctionFragment; + "expectEmit(address)": FunctionFragment; + "expectRevert(bytes4)": FunctionFragment; + "expectRevert(bytes)": FunctionFragment; + "expectRevert()": FunctionFragment; + "expectSafeMemory(uint64,uint64)": FunctionFragment; + "expectSafeMemoryCall(uint64,uint64)": FunctionFragment; + "fee(uint256)": FunctionFragment; + "ffi(string[])": FunctionFragment; + "fsMetadata(string)": FunctionFragment; + "getBlobBaseFee()": FunctionFragment; + "getBlobhashes()": FunctionFragment; + "getBlockNumber()": FunctionFragment; + "getBlockTimestamp()": FunctionFragment; + "getCode(string)": FunctionFragment; + "getDeployedCode(string)": FunctionFragment; + "getLabel(address)": FunctionFragment; + "getMappingKeyAndParentOf(address,bytes32)": FunctionFragment; + "getMappingLength(address,bytes32)": FunctionFragment; + "getMappingSlotAt(address,bytes32,uint256)": FunctionFragment; + "getNonce(address)": FunctionFragment; + "getNonce((address,uint256,uint256,uint256))": FunctionFragment; + "getRecordedLogs()": FunctionFragment; + "indexOf(string,string)": FunctionFragment; + "isContext(uint8)": FunctionFragment; + "isDir(string)": FunctionFragment; + "isFile(string)": FunctionFragment; + "isPersistent(address)": FunctionFragment; + "keyExists(string,string)": FunctionFragment; + "keyExistsJson(string,string)": FunctionFragment; + "keyExistsToml(string,string)": FunctionFragment; + "label(address,string)": FunctionFragment; + "lastCallGas()": FunctionFragment; + "load(address,bytes32)": FunctionFragment; + "loadAllocs(string)": FunctionFragment; + "makePersistent(address[])": FunctionFragment; + "makePersistent(address,address)": FunctionFragment; + "makePersistent(address)": FunctionFragment; + "makePersistent(address,address,address)": FunctionFragment; + "mockCall(address,uint256,bytes,bytes)": FunctionFragment; + "mockCall(address,bytes,bytes)": FunctionFragment; + "mockCallRevert(address,uint256,bytes,bytes)": FunctionFragment; + "mockCallRevert(address,bytes,bytes)": FunctionFragment; + "parseAddress(string)": FunctionFragment; + "parseBool(string)": FunctionFragment; + "parseBytes(string)": FunctionFragment; + "parseBytes32(string)": FunctionFragment; + "parseInt(string)": FunctionFragment; + "parseJson(string)": FunctionFragment; + "parseJson(string,string)": FunctionFragment; + "parseJsonAddress(string,string)": FunctionFragment; + "parseJsonAddressArray(string,string)": FunctionFragment; + "parseJsonBool(string,string)": FunctionFragment; + "parseJsonBoolArray(string,string)": FunctionFragment; + "parseJsonBytes(string,string)": FunctionFragment; + "parseJsonBytes32(string,string)": FunctionFragment; + "parseJsonBytes32Array(string,string)": FunctionFragment; + "parseJsonBytesArray(string,string)": FunctionFragment; + "parseJsonInt(string,string)": FunctionFragment; + "parseJsonIntArray(string,string)": FunctionFragment; + "parseJsonKeys(string,string)": FunctionFragment; + "parseJsonString(string,string)": FunctionFragment; + "parseJsonStringArray(string,string)": FunctionFragment; + "parseJsonUint(string,string)": FunctionFragment; + "parseJsonUintArray(string,string)": FunctionFragment; + "parseToml(string,string)": FunctionFragment; + "parseToml(string)": FunctionFragment; + "parseTomlAddress(string,string)": FunctionFragment; + "parseTomlAddressArray(string,string)": FunctionFragment; + "parseTomlBool(string,string)": FunctionFragment; + "parseTomlBoolArray(string,string)": FunctionFragment; + "parseTomlBytes(string,string)": FunctionFragment; + "parseTomlBytes32(string,string)": FunctionFragment; + "parseTomlBytes32Array(string,string)": FunctionFragment; + "parseTomlBytesArray(string,string)": FunctionFragment; + "parseTomlInt(string,string)": FunctionFragment; + "parseTomlIntArray(string,string)": FunctionFragment; + "parseTomlKeys(string,string)": FunctionFragment; + "parseTomlString(string,string)": FunctionFragment; + "parseTomlStringArray(string,string)": FunctionFragment; + "parseTomlUint(string,string)": FunctionFragment; + "parseTomlUintArray(string,string)": FunctionFragment; + "parseUint(string)": FunctionFragment; + "pauseGasMetering()": FunctionFragment; + "prank(address,address)": FunctionFragment; + "prank(address)": FunctionFragment; + "prevrandao(bytes32)": FunctionFragment; + "prevrandao(uint256)": FunctionFragment; + "projectRoot()": FunctionFragment; + "prompt(string)": FunctionFragment; + "promptAddress(string)": FunctionFragment; + "promptSecret(string)": FunctionFragment; + "promptSecretUint(string)": FunctionFragment; + "promptUint(string)": FunctionFragment; + "randomAddress()": FunctionFragment; + "randomUint()": FunctionFragment; + "randomUint(uint256,uint256)": FunctionFragment; + "readCallers()": FunctionFragment; + "readDir(string,uint64)": FunctionFragment; + "readDir(string,uint64,bool)": FunctionFragment; + "readDir(string)": FunctionFragment; + "readFile(string)": FunctionFragment; + "readFileBinary(string)": FunctionFragment; + "readLine(string)": FunctionFragment; + "readLink(string)": FunctionFragment; + "record()": FunctionFragment; + "recordLogs()": FunctionFragment; + "rememberKey(uint256)": FunctionFragment; + "removeDir(string,bool)": FunctionFragment; + "removeFile(string)": FunctionFragment; + "replace(string,string,string)": FunctionFragment; + "resetNonce(address)": FunctionFragment; + "resumeGasMetering()": FunctionFragment; + "revertTo(uint256)": FunctionFragment; + "revertToAndDelete(uint256)": FunctionFragment; + "revokePersistent(address[])": FunctionFragment; + "revokePersistent(address)": FunctionFragment; + "roll(uint256)": FunctionFragment; + "rollFork(bytes32)": FunctionFragment; + "rollFork(uint256,uint256)": FunctionFragment; + "rollFork(uint256)": FunctionFragment; + "rollFork(uint256,bytes32)": FunctionFragment; + "rpc(string,string)": FunctionFragment; + "rpcUrl(string)": FunctionFragment; + "rpcUrlStructs()": FunctionFragment; + "rpcUrls()": FunctionFragment; + "selectFork(uint256)": FunctionFragment; + "serializeAddress(string,string,address[])": FunctionFragment; + "serializeAddress(string,string,address)": FunctionFragment; + "serializeBool(string,string,bool[])": FunctionFragment; + "serializeBool(string,string,bool)": FunctionFragment; + "serializeBytes(string,string,bytes[])": FunctionFragment; + "serializeBytes(string,string,bytes)": FunctionFragment; + "serializeBytes32(string,string,bytes32[])": FunctionFragment; + "serializeBytes32(string,string,bytes32)": FunctionFragment; + "serializeInt(string,string,int256)": FunctionFragment; + "serializeInt(string,string,int256[])": FunctionFragment; + "serializeJson(string,string)": FunctionFragment; + "serializeString(string,string,string[])": FunctionFragment; + "serializeString(string,string,string)": FunctionFragment; + "serializeUint(string,string,uint256)": FunctionFragment; + "serializeUint(string,string,uint256[])": FunctionFragment; + "serializeUintToHex(string,string,uint256)": FunctionFragment; + "setEnv(string,string)": FunctionFragment; + "setNonce(address,uint64)": FunctionFragment; + "setNonceUnsafe(address,uint64)": FunctionFragment; + "sign(bytes32)": FunctionFragment; + "sign(address,bytes32)": FunctionFragment; + "sign((address,uint256,uint256,uint256),bytes32)": FunctionFragment; + "sign(uint256,bytes32)": FunctionFragment; + "signP256(uint256,bytes32)": FunctionFragment; + "skip(bool)": FunctionFragment; + "sleep(uint256)": FunctionFragment; + "snapshot()": FunctionFragment; + "split(string,string)": FunctionFragment; + "startBroadcast()": FunctionFragment; + "startBroadcast(address)": FunctionFragment; + "startBroadcast(uint256)": FunctionFragment; + "startMappingRecording()": FunctionFragment; + "startPrank(address)": FunctionFragment; + "startPrank(address,address)": FunctionFragment; + "startStateDiffRecording()": FunctionFragment; + "stopAndReturnStateDiff()": FunctionFragment; + "stopBroadcast()": FunctionFragment; + "stopExpectSafeMemory()": FunctionFragment; + "stopMappingRecording()": FunctionFragment; + "stopPrank()": FunctionFragment; + "store(address,bytes32,bytes32)": FunctionFragment; + "toBase64(string)": FunctionFragment; + "toBase64(bytes)": FunctionFragment; + "toBase64URL(string)": FunctionFragment; + "toBase64URL(bytes)": FunctionFragment; + "toLowercase(string)": FunctionFragment; + "toString(address)": FunctionFragment; + "toString(uint256)": FunctionFragment; + "toString(bytes)": FunctionFragment; + "toString(bool)": FunctionFragment; + "toString(int256)": FunctionFragment; + "toString(bytes32)": FunctionFragment; + "toUppercase(string)": FunctionFragment; + "transact(uint256,bytes32)": FunctionFragment; + "transact(bytes32)": FunctionFragment; + "trim(string)": FunctionFragment; + "tryFfi(string[])": FunctionFragment; + "txGasPrice(uint256)": FunctionFragment; + "unixTime()": FunctionFragment; + "warp(uint256)": FunctionFragment; + "writeFile(string,string)": FunctionFragment; + "writeFileBinary(string,bytes)": FunctionFragment; + "writeJson(string,string,string)": FunctionFragment; + "writeJson(string,string)": FunctionFragment; + "writeLine(string,string)": FunctionFragment; + "writeToml(string,string,string)": FunctionFragment; + "writeToml(string,string)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "accesses" + | "activeFork" + | "addr" + | "allowCheatcodes" + | "assertApproxEqAbs(uint256,uint256,uint256)" + | "assertApproxEqAbs(int256,int256,uint256)" + | "assertApproxEqAbs(int256,int256,uint256,string)" + | "assertApproxEqAbs(uint256,uint256,uint256,string)" + | "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)" + | "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)" + | "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)" + | "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)" + | "assertApproxEqRel(uint256,uint256,uint256,string)" + | "assertApproxEqRel(uint256,uint256,uint256)" + | "assertApproxEqRel(int256,int256,uint256,string)" + | "assertApproxEqRel(int256,int256,uint256)" + | "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)" + | "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)" + | "assertApproxEqRelDecimal(int256,int256,uint256,uint256)" + | "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)" + | "assertEq(bytes32[],bytes32[])" + | "assertEq(int256[],int256[],string)" + | "assertEq(address,address,string)" + | "assertEq(string,string,string)" + | "assertEq(address[],address[])" + | "assertEq(address[],address[],string)" + | "assertEq(bool,bool,string)" + | "assertEq(address,address)" + | "assertEq(uint256[],uint256[],string)" + | "assertEq(bool[],bool[])" + | "assertEq(int256[],int256[])" + | "assertEq(int256,int256,string)" + | "assertEq(bytes32,bytes32)" + | "assertEq(uint256,uint256,string)" + | "assertEq(uint256[],uint256[])" + | "assertEq(bytes,bytes)" + | "assertEq(uint256,uint256)" + | "assertEq(bytes32,bytes32,string)" + | "assertEq(string[],string[])" + | "assertEq(bytes32[],bytes32[],string)" + | "assertEq(bytes,bytes,string)" + | "assertEq(bool[],bool[],string)" + | "assertEq(bytes[],bytes[])" + | "assertEq(string[],string[],string)" + | "assertEq(string,string)" + | "assertEq(bytes[],bytes[],string)" + | "assertEq(bool,bool)" + | "assertEq(int256,int256)" + | "assertEqDecimal(uint256,uint256,uint256)" + | "assertEqDecimal(int256,int256,uint256)" + | "assertEqDecimal(int256,int256,uint256,string)" + | "assertEqDecimal(uint256,uint256,uint256,string)" + | "assertFalse(bool,string)" + | "assertFalse(bool)" + | "assertGe(int256,int256)" + | "assertGe(int256,int256,string)" + | "assertGe(uint256,uint256)" + | "assertGe(uint256,uint256,string)" + | "assertGeDecimal(uint256,uint256,uint256)" + | "assertGeDecimal(int256,int256,uint256,string)" + | "assertGeDecimal(uint256,uint256,uint256,string)" + | "assertGeDecimal(int256,int256,uint256)" + | "assertGt(int256,int256)" + | "assertGt(uint256,uint256,string)" + | "assertGt(uint256,uint256)" + | "assertGt(int256,int256,string)" + | "assertGtDecimal(int256,int256,uint256,string)" + | "assertGtDecimal(uint256,uint256,uint256,string)" + | "assertGtDecimal(int256,int256,uint256)" + | "assertGtDecimal(uint256,uint256,uint256)" + | "assertLe(int256,int256,string)" + | "assertLe(uint256,uint256)" + | "assertLe(int256,int256)" + | "assertLe(uint256,uint256,string)" + | "assertLeDecimal(int256,int256,uint256)" + | "assertLeDecimal(uint256,uint256,uint256,string)" + | "assertLeDecimal(int256,int256,uint256,string)" + | "assertLeDecimal(uint256,uint256,uint256)" + | "assertLt(int256,int256)" + | "assertLt(uint256,uint256,string)" + | "assertLt(int256,int256,string)" + | "assertLt(uint256,uint256)" + | "assertLtDecimal(uint256,uint256,uint256)" + | "assertLtDecimal(int256,int256,uint256,string)" + | "assertLtDecimal(uint256,uint256,uint256,string)" + | "assertLtDecimal(int256,int256,uint256)" + | "assertNotEq(bytes32[],bytes32[])" + | "assertNotEq(int256[],int256[])" + | "assertNotEq(bool,bool,string)" + | "assertNotEq(bytes[],bytes[],string)" + | "assertNotEq(bool,bool)" + | "assertNotEq(bool[],bool[])" + | "assertNotEq(bytes,bytes)" + | "assertNotEq(address[],address[])" + | "assertNotEq(int256,int256,string)" + | "assertNotEq(uint256[],uint256[])" + | "assertNotEq(bool[],bool[],string)" + | "assertNotEq(string,string)" + | "assertNotEq(address[],address[],string)" + | "assertNotEq(string,string,string)" + | "assertNotEq(address,address,string)" + | "assertNotEq(bytes32,bytes32)" + | "assertNotEq(bytes,bytes,string)" + | "assertNotEq(uint256,uint256,string)" + | "assertNotEq(uint256[],uint256[],string)" + | "assertNotEq(address,address)" + | "assertNotEq(bytes32,bytes32,string)" + | "assertNotEq(string[],string[],string)" + | "assertNotEq(uint256,uint256)" + | "assertNotEq(bytes32[],bytes32[],string)" + | "assertNotEq(string[],string[])" + | "assertNotEq(int256[],int256[],string)" + | "assertNotEq(bytes[],bytes[])" + | "assertNotEq(int256,int256)" + | "assertNotEqDecimal(int256,int256,uint256)" + | "assertNotEqDecimal(int256,int256,uint256,string)" + | "assertNotEqDecimal(uint256,uint256,uint256)" + | "assertNotEqDecimal(uint256,uint256,uint256,string)" + | "assertTrue(bool)" + | "assertTrue(bool,string)" + | "assume" + | "blobBaseFee" + | "blobhashes" + | "breakpoint(string)" + | "breakpoint(string,bool)" + | "broadcast()" + | "broadcast(address)" + | "broadcast(uint256)" + | "chainId" + | "clearMockedCalls" + | "closeFile" + | "coinbase" + | "computeCreate2Address(bytes32,bytes32)" + | "computeCreate2Address(bytes32,bytes32,address)" + | "computeCreateAddress" + | "copyFile" + | "createDir" + | "createFork(string)" + | "createFork(string,uint256)" + | "createFork(string,bytes32)" + | "createSelectFork(string,uint256)" + | "createSelectFork(string,bytes32)" + | "createSelectFork(string)" + | "createWallet(string)" + | "createWallet(uint256)" + | "createWallet(uint256,string)" + | "deal" + | "deleteSnapshot" + | "deleteSnapshots" + | "deriveKey(string,string,uint32,string)" + | "deriveKey(string,uint32,string)" + | "deriveKey(string,uint32)" + | "deriveKey(string,string,uint32)" + | "difficulty" + | "dumpState" + | "ensNamehash" + | "envAddress(string)" + | "envAddress(string,string)" + | "envBool(string)" + | "envBool(string,string)" + | "envBytes(string)" + | "envBytes(string,string)" + | "envBytes32(string,string)" + | "envBytes32(string)" + | "envExists" + | "envInt(string,string)" + | "envInt(string)" + | "envOr(string,string,bytes32[])" + | "envOr(string,string,int256[])" + | "envOr(string,bool)" + | "envOr(string,address)" + | "envOr(string,uint256)" + | "envOr(string,string,bytes[])" + | "envOr(string,string,uint256[])" + | "envOr(string,string,string[])" + | "envOr(string,bytes)" + | "envOr(string,bytes32)" + | "envOr(string,int256)" + | "envOr(string,string,address[])" + | "envOr(string,string)" + | "envOr(string,string,bool[])" + | "envString(string,string)" + | "envString(string)" + | "envUint(string)" + | "envUint(string,string)" + | "etch" + | "eth_getLogs" + | "exists" + | "expectCall(address,uint256,uint64,bytes)" + | "expectCall(address,uint256,uint64,bytes,uint64)" + | "expectCall(address,uint256,bytes,uint64)" + | "expectCall(address,bytes)" + | "expectCall(address,bytes,uint64)" + | "expectCall(address,uint256,bytes)" + | "expectCallMinGas(address,uint256,uint64,bytes)" + | "expectCallMinGas(address,uint256,uint64,bytes,uint64)" + | "expectEmit()" + | "expectEmit(bool,bool,bool,bool)" + | "expectEmit(bool,bool,bool,bool,address)" + | "expectEmit(address)" + | "expectRevert(bytes4)" + | "expectRevert(bytes)" + | "expectRevert()" + | "expectSafeMemory" + | "expectSafeMemoryCall" + | "fee" + | "ffi" + | "fsMetadata" + | "getBlobBaseFee" + | "getBlobhashes" + | "getBlockNumber" + | "getBlockTimestamp" + | "getCode" + | "getDeployedCode" + | "getLabel" + | "getMappingKeyAndParentOf" + | "getMappingLength" + | "getMappingSlotAt" + | "getNonce(address)" + | "getNonce((address,uint256,uint256,uint256))" + | "getRecordedLogs" + | "indexOf" + | "isContext" + | "isDir" + | "isFile" + | "isPersistent" + | "keyExists" + | "keyExistsJson" + | "keyExistsToml" + | "label" + | "lastCallGas" + | "load" + | "loadAllocs" + | "makePersistent(address[])" + | "makePersistent(address,address)" + | "makePersistent(address)" + | "makePersistent(address,address,address)" + | "mockCall(address,uint256,bytes,bytes)" + | "mockCall(address,bytes,bytes)" + | "mockCallRevert(address,uint256,bytes,bytes)" + | "mockCallRevert(address,bytes,bytes)" + | "parseAddress" + | "parseBool" + | "parseBytes" + | "parseBytes32" + | "parseInt" + | "parseJson(string)" + | "parseJson(string,string)" + | "parseJsonAddress" + | "parseJsonAddressArray" + | "parseJsonBool" + | "parseJsonBoolArray" + | "parseJsonBytes" + | "parseJsonBytes32" + | "parseJsonBytes32Array" + | "parseJsonBytesArray" + | "parseJsonInt" + | "parseJsonIntArray" + | "parseJsonKeys" + | "parseJsonString" + | "parseJsonStringArray" + | "parseJsonUint" + | "parseJsonUintArray" + | "parseToml(string,string)" + | "parseToml(string)" + | "parseTomlAddress" + | "parseTomlAddressArray" + | "parseTomlBool" + | "parseTomlBoolArray" + | "parseTomlBytes" + | "parseTomlBytes32" + | "parseTomlBytes32Array" + | "parseTomlBytesArray" + | "parseTomlInt" + | "parseTomlIntArray" + | "parseTomlKeys" + | "parseTomlString" + | "parseTomlStringArray" + | "parseTomlUint" + | "parseTomlUintArray" + | "parseUint" + | "pauseGasMetering" + | "prank(address,address)" + | "prank(address)" + | "prevrandao(bytes32)" + | "prevrandao(uint256)" + | "projectRoot" + | "prompt" + | "promptAddress" + | "promptSecret" + | "promptSecretUint" + | "promptUint" + | "randomAddress" + | "randomUint()" + | "randomUint(uint256,uint256)" + | "readCallers" + | "readDir(string,uint64)" + | "readDir(string,uint64,bool)" + | "readDir(string)" + | "readFile" + | "readFileBinary" + | "readLine" + | "readLink" + | "record" + | "recordLogs" + | "rememberKey" + | "removeDir" + | "removeFile" + | "replace" + | "resetNonce" + | "resumeGasMetering" + | "revertTo" + | "revertToAndDelete" + | "revokePersistent(address[])" + | "revokePersistent(address)" + | "roll" + | "rollFork(bytes32)" + | "rollFork(uint256,uint256)" + | "rollFork(uint256)" + | "rollFork(uint256,bytes32)" + | "rpc" + | "rpcUrl" + | "rpcUrlStructs" + | "rpcUrls" + | "selectFork" + | "serializeAddress(string,string,address[])" + | "serializeAddress(string,string,address)" + | "serializeBool(string,string,bool[])" + | "serializeBool(string,string,bool)" + | "serializeBytes(string,string,bytes[])" + | "serializeBytes(string,string,bytes)" + | "serializeBytes32(string,string,bytes32[])" + | "serializeBytes32(string,string,bytes32)" + | "serializeInt(string,string,int256)" + | "serializeInt(string,string,int256[])" + | "serializeJson" + | "serializeString(string,string,string[])" + | "serializeString(string,string,string)" + | "serializeUint(string,string,uint256)" + | "serializeUint(string,string,uint256[])" + | "serializeUintToHex" + | "setEnv" + | "setNonce" + | "setNonceUnsafe" + | "sign(bytes32)" + | "sign(address,bytes32)" + | "sign((address,uint256,uint256,uint256),bytes32)" + | "sign(uint256,bytes32)" + | "signP256" + | "skip" + | "sleep" + | "snapshot" + | "split" + | "startBroadcast()" + | "startBroadcast(address)" + | "startBroadcast(uint256)" + | "startMappingRecording" + | "startPrank(address)" + | "startPrank(address,address)" + | "startStateDiffRecording" + | "stopAndReturnStateDiff" + | "stopBroadcast" + | "stopExpectSafeMemory" + | "stopMappingRecording" + | "stopPrank" + | "store" + | "toBase64(string)" + | "toBase64(bytes)" + | "toBase64URL(string)" + | "toBase64URL(bytes)" + | "toLowercase" + | "toString(address)" + | "toString(uint256)" + | "toString(bytes)" + | "toString(bool)" + | "toString(int256)" + | "toString(bytes32)" + | "toUppercase" + | "transact(uint256,bytes32)" + | "transact(bytes32)" + | "trim" + | "tryFfi" + | "txGasPrice" + | "unixTime" + | "warp" + | "writeFile" + | "writeFileBinary" + | "writeJson(string,string,string)" + | "writeJson(string,string)" + | "writeLine" + | "writeToml(string,string,string)" + | "writeToml(string,string)" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "accesses", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "activeFork", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "addr", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "allowCheatcodes", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32[],bytes32[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256[],int256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address,address,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address[],address[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address[],address[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool,bool,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256[],uint256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool[],bool[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256[],int256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256[],uint256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32,bytes32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string[],string[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32[],bytes32[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes,bytes,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool[],bool[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes[],bytes[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string[],string[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes[],bytes[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertFalse(bool,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertFalse(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGe(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGt(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGt(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGt(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGt(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLe(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLe(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLe(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLe(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLt(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32[],bytes32[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256[],int256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool,bool,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes[],bytes[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool[],bool[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address[],address[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256[],uint256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool[],bool[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address[],address[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address,address,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes,bytes,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256[],uint256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32,bytes32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string[],string[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32[],bytes32[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string[],string[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256[],int256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes[],bytes[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertTrue(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertTrue(bool,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assume", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "blobBaseFee", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "blobhashes", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "breakpoint(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "breakpoint(string,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "broadcast()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "broadcast(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "broadcast(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "chainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "clearMockedCalls", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "closeFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "coinbase", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "computeCreate2Address(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "computeCreate2Address(bytes32,bytes32,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "computeCreateAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "copyFile", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createDir", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createFork(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createFork(string,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createFork(string,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createSelectFork(string,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createSelectFork(string,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createSelectFork(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(uint256,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deal", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deleteSnapshot", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deleteSnapshots", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,string,uint32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,uint32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,uint32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,string,uint32)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "difficulty", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "dumpState", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "ensNamehash", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envAddress(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envAddress(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBool(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBool(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes32(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes32(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envExists", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envInt(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envInt(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bytes32[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,int256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bytes[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,uint256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,string[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,address[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bool[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envString(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envString(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envUint(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envUint(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "etch", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "eth_getLogs", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "exists", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,uint256,uint64,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,uint256,uint64,bytes,uint64)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,uint256,bytes,uint64)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,bytes,uint64)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCall(address,uint256,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCallMinGas(address,uint256,uint64,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectCallMinGas(address,uint256,uint64,bytes,uint64)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectEmit()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "expectEmit(bool,bool,bool,bool)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectEmit(bool,bool,bool,bool,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "expectEmit(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectRevert(bytes4)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectRevert(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectRevert()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "expectSafeMemory", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "expectSafeMemoryCall", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "fee", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "ffi", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "fsMetadata", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getBlobBaseFee", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlobhashes", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlockNumber", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlockTimestamp", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCode", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getDeployedCode", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getLabel", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingKeyAndParentOf", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingLength", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingSlotAt", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "getNonce(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getNonce((address,uint256,uint256,uint256))", + values: [VmSafe.WalletStruct] + ): string; + encodeFunctionData( + functionFragment: "getRecordedLogs", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "indexOf", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isContext", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isDir", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isPersistent", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExists", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExistsJson", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExistsToml", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "label", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "lastCallGas", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "load", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "loadAllocs", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "makePersistent(address[])", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "makePersistent(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "makePersistent(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "makePersistent(address,address,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "mockCall(address,uint256,bytes,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "mockCall(address,bytes,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "mockCallRevert(address,uint256,bytes,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "mockCallRevert(address,bytes,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "parseAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBool", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBytes", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBytes32", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseInt", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJson(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJson(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonAddressArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBool", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBoolArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes32", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes32Array", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytesArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonInt", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonIntArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonKeys", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonString", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonStringArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonUint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonUintArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseToml(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseToml(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlAddressArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBool", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBoolArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes32", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes32Array", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytesArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlInt", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlIntArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlKeys", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlString", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlStringArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlUint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlUintArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "pauseGasMetering", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "prank(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "prank(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "prevrandao(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "prevrandao(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "projectRoot", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "prompt", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptSecret", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptSecretUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "randomAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "randomUint()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "randomUint(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readCallers", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "readDir(string,uint64)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readDir(string,uint64,bool)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "readDir(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readFileBinary", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readLine", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readLink", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "record", values?: undefined): string; + encodeFunctionData( + functionFragment: "recordLogs", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rememberKey", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "removeDir", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "removeFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "replace", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "resetNonce", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "resumeGasMetering", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "revertTo", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "revertToAndDelete", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "revokePersistent(address[])", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "revokePersistent(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "roll", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rollFork(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rollFork(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rollFork(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rollFork(uint256,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rpc", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rpcUrl", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rpcUrlStructs", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "rpcUrls", values?: undefined): string; + encodeFunctionData( + functionFragment: "selectFork", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "serializeAddress(string,string,address[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeAddress(string,string,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBool(string,string,bool[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBool(string,string,bool)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes(string,string,bytes[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes(string,string,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes32(string,string,bytes32[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes32(string,string,bytes32)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeInt(string,string,int256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeInt(string,string,int256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeJson", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "serializeString(string,string,string[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeString(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUint(string,string,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUint(string,string,uint256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUintToHex", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setEnv", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "setNonce", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "setNonceUnsafe", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(address,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign((address,uint256,uint256,uint256),bytes32)", + values: [VmSafe.WalletStruct, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(uint256,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "signP256", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "skip", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sleep", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "snapshot", values?: undefined): string; + encodeFunctionData( + functionFragment: "split", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startBroadcast()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "startBroadcast(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startBroadcast(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startMappingRecording", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "startPrank(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startPrank(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startStateDiffRecording", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopAndReturnStateDiff", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopBroadcast", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopExpectSafeMemory", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopMappingRecording", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "stopPrank", values?: undefined): string; + encodeFunctionData( + functionFragment: "store", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "toBase64(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64URL(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64URL(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toLowercase", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(int256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toUppercase", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transact(uint256,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transact(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "trim", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tryFfi", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "txGasPrice", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "unixTime", values?: undefined): string; + encodeFunctionData( + functionFragment: "warp", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeFile", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeFileBinary", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeJson(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "writeJson(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeLine", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeToml(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "writeToml(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "accesses", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "activeFork", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "allowCheatcodes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32[],bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256[],int256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address,address,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address[],address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address[],address[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool,bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256[],uint256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool[],bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256[],int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256[],uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32,bytes32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string[],string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32[],bytes32[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes,bytes,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool[],bool[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes[],bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string[],string[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes[],bytes[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertFalse(bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertFalse(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32[],bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256[],int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool,bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes[],bytes[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool[],bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address[],address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256[],uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool[],bool[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address[],address[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address,address,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes,bytes,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256[],uint256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32,bytes32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string[],string[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32[],bytes32[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string[],string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256[],int256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes[],bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertTrue(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertTrue(bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "assume", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "blobBaseFee", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "blobhashes", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "breakpoint(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "breakpoint(string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "chainId", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "clearMockedCalls", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "closeFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "coinbase", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "computeCreate2Address(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "computeCreate2Address(bytes32,bytes32,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "computeCreateAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "copyFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "createDir", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "createFork(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createFork(string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createFork(string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createSelectFork(string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createSelectFork(string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createSelectFork(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createWallet(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createWallet(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createWallet(uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "deal", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "deleteSnapshot", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deleteSnapshots", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,string,uint32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,uint32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,uint32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,string,uint32)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "difficulty", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "dumpState", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "ensNamehash", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envAddress(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envAddress(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBool(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBool(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes32(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes32(string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "envExists", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "envInt(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envInt(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envString(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envString(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envUint(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envUint(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "etch", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "eth_getLogs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "exists", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,uint256,uint64,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,uint256,uint64,bytes,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,uint256,bytes,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,bytes,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCall(address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCallMinGas(address,uint256,uint64,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectCallMinGas(address,uint256,uint64,bytes,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectEmit()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectEmit(bool,bool,bool,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectEmit(bool,bool,bool,bool,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectEmit(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectRevert(bytes4)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectRevert(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectRevert()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectSafeMemory", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "expectSafeMemoryCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "fee", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "ffi", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "fsMetadata", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getBlobBaseFee", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlobhashes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlockNumber", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlockTimestamp", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getCode", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getDeployedCode", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getLabel", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getMappingKeyAndParentOf", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMappingLength", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMappingSlotAt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getNonce(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getNonce((address,uint256,uint256,uint256))", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getRecordedLogs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "indexOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isContext", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isDir", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "isPersistent", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "keyExists", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "keyExistsJson", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "keyExistsToml", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "label", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "lastCallGas", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "load", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "loadAllocs", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "makePersistent(address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "makePersistent(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "makePersistent(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "makePersistent(address,address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mockCall(address,uint256,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mockCall(address,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mockCallRevert(address,uint256,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "mockCallRevert(address,bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseBool", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "parseBytes", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "parseBytes32", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseInt", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "parseJson(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJson(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonAddressArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBool", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBoolArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes32", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes32Array", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytesArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonInt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonIntArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonKeys", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonString", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonStringArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonUint", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonUintArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseToml(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseToml(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlAddressArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBool", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBoolArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes32", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes32Array", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytesArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlInt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlIntArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlKeys", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlString", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlStringArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlUint", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlUintArray", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseUint", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "pauseGasMetering", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "prank(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "prank(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "prevrandao(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "prevrandao(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "projectRoot", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "prompt", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "promptAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "promptSecret", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "promptSecretUint", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "promptUint", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "randomAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "randomUint()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "randomUint(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readCallers", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string,uint64,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "readFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "readFileBinary", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "readLine", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "readLink", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "record", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "recordLogs", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rememberKey", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "removeDir", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "removeFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "replace", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "resetNonce", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "resumeGasMetering", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "revertTo", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "revertToAndDelete", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "revokePersistent(address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "revokePersistent(address)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "roll", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rollFork(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rollFork(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rollFork(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "rollFork(uint256,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "rpc", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "rpcUrl", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rpcUrlStructs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "rpcUrls", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "selectFork", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "serializeAddress(string,string,address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeAddress(string,string,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBool(string,string,bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBool(string,string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes(string,string,bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes(string,string,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes32(string,string,bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes32(string,string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeInt(string,string,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeInt(string,string,int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeJson", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeString(string,string,string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeString(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUint(string,string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUint(string,string,uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUintToHex", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setEnv", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setNonce", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "setNonceUnsafe", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign(address,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign((address,uint256,uint256,uint256),bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign(uint256,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "signP256", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "skip", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sleep", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "snapshot", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "split", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "startBroadcast()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startBroadcast(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startBroadcast(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startMappingRecording", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startPrank(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startPrank(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startStateDiffRecording", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopAndReturnStateDiff", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopBroadcast", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopExpectSafeMemory", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopMappingRecording", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "stopPrank", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "store", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "toBase64(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64URL(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64URL(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toLowercase", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toUppercase", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transact(uint256,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transact(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "trim", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "tryFfi", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "txGasPrice", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "unixTime", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "warp", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "writeFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "writeFileBinary", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeJson(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeJson(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "writeLine", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "writeToml(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeToml(string,string)", + data: BytesLike + ): Result; + + events: {}; +} + +export interface Vm extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: VmInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + activeFork( + overrides?: CallOverrides + ): Promise<[BigNumber] & { forkId: BigNumber }>; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { keyAddr: string }>; + + allowCheatcodes( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + blobBaseFee( + newBlobBaseFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + blobhashes( + hashes: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + chainId( + newChainId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + clearMockedCalls( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + coinbase( + newCoinbase: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deal( + account: PromiseOrValue, + newBalance: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshot( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshots( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + difficulty( + newDifficulty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + dumpState( + pathToStateJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { value: boolean }>; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]] & { value: boolean[] }>; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { result: boolean }>; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { value: boolean }>; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[boolean[]] & { value: boolean[] }>; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + etch( + target: PromiseOrValue, + newRuntimeBytecode: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes,uint64)"( + callee: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool,address)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(address)"( + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes4)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemory( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemoryCall( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fee( + newBasefee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.FsMetadataStructOutput] & { + metadata: VmSafe.FsMetadataStructOutput; + } + >; + + getBlobBaseFee( + overrides?: CallOverrides + ): Promise<[BigNumber] & { blobBaseFee: BigNumber }>; + + getBlobhashes( + overrides?: CallOverrides + ): Promise<[string[]] & { hashes: string[] }>; + + getBlockNumber( + overrides?: CallOverrides + ): Promise<[BigNumber] & { height: BigNumber }>; + + getBlockTimestamp( + overrides?: CallOverrides + ): Promise<[BigNumber] & { timestamp: BigNumber }>; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { creationBytecode: string }>; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { runtimeBytecode: string }>; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { currentLabel: string }>; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { nonce: BigNumber }>; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { result: boolean }>; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isPersistent( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { persistent: boolean }>; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas( + overrides?: CallOverrides + ): Promise<[VmSafe.GasStructOutput] & { gas: VmSafe.GasStructOutput }>; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + loadAllocs( + pathToAllocsJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + account2: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { parsedValue: boolean }>; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { parsedValue: BigNumber }>; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]]>; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { keys: string[] }>; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]]>; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { keys: string[] }>; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { parsedValue: BigNumber }>; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(bytes32)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(uint256)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot( + overrides?: CallOverrides + ): Promise<[string] & { path: string }>; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + readCallers( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { line: string }>; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { targetPath: string }>; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + resetNonce( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertTo( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertToAndDelete( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + roll( + newHeight: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,uint256)"( + forkId: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256)"( + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { json: string }>; + + rpcUrlStructs( + overrides?: CallOverrides + ): Promise<[VmSafe.RpcStructOutput[]] & { urls: VmSafe.RpcStructOutput[] }>; + + rpcUrls( + overrides?: CallOverrides + ): Promise<[[string, string][]] & { urls: [string, string][] }>; + + selectFork( + forkId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonce( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonceUnsafe( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + skip( + skipTest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + snapshot( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { outputs: string[] }>; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopExpectSafeMemory( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopPrank( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + store( + target: PromiseOrValue, + slot: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + "transact(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "transact(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + txGasPrice( + newGasPrice: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + warp( + newTimestamp: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + activeFork(overrides?: CallOverrides): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + allowCheatcodes( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + blobBaseFee( + newBlobBaseFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + blobhashes( + hashes: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + chainId( + newChainId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + clearMockedCalls( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + coinbase( + newCoinbase: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deal( + account: PromiseOrValue, + newBalance: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshot( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshots( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + difficulty( + newDifficulty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + dumpState( + pathToStateJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + etch( + target: PromiseOrValue, + newRuntimeBytecode: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes,uint64)"( + callee: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool,address)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(address)"( + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes4)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemory( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemoryCall( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fee( + newBasefee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlobhashes(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isPersistent( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + loadAllocs( + pathToAllocsJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + account2: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(bytes32)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(uint256)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + readCallers( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resetNonce( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertTo( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertToAndDelete( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + roll( + newHeight: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,uint256)"( + forkId: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256)"( + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise<[string, string][]>; + + selectFork( + forkId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonce( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonceUnsafe( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + skip( + skipTest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + snapshot( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopExpectSafeMemory( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopPrank( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + store( + target: PromiseOrValue, + slot: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "transact(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "transact(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + txGasPrice( + newGasPrice: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + warp( + newTimestamp: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + accesses( + target: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [string[], string[]] & { readSlots: string[]; writeSlots: string[] } + >; + + activeFork(overrides?: CallOverrides): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + allowCheatcodes( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + blobBaseFee( + newBlobBaseFee: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + blobhashes( + hashes: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "broadcast()"(overrides?: CallOverrides): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + chainId( + newChainId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + clearMockedCalls(overrides?: CallOverrides): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + coinbase( + newCoinbase: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createSelectFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createSelectFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createSelectFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + deal( + account: PromiseOrValue, + newBalance: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + deleteSnapshot( + snapshotId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + deleteSnapshots(overrides?: CallOverrides): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + difficulty( + newDifficulty: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + dumpState( + pathToStateJson: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + etch( + target: PromiseOrValue, + newRuntimeBytecode: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,uint256,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,bytes,uint64)"( + callee: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCall(address,uint256,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectEmit()"(overrides?: CallOverrides): Promise; + + "expectEmit(bool,bool,bool,bool)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectEmit(bool,bool,bool,bool,address)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + emitter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectEmit(address)"( + emitter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectRevert(bytes4)"( + revertData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectRevert(bytes)"( + revertData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "expectRevert()"(overrides?: CallOverrides): Promise; + + expectSafeMemory( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + expectSafeMemoryCall( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + fee( + newBasefee: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlobhashes(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [boolean, string, string] & { + found: boolean; + key: string; + parent: string; + } + >; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: CallOverrides + ): Promise; + + getRecordedLogs( + overrides?: CallOverrides + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isPersistent( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + loadAllocs( + pathToAllocsJson: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "makePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "makePersistent(address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "makePersistent(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "makePersistent(address,address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + account2: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "mockCall(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "mockCall(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "mockCallRevert(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "mockCallRevert(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering(overrides?: CallOverrides): Promise; + + "prank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "prank(address)"( + msgSender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "prevrandao(bytes32)"( + newPrevrandao: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "prevrandao(uint256)"( + newPrevrandao: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + randomAddress(overrides?: CallOverrides): Promise; + + "randomUint()"(overrides?: CallOverrides): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readCallers( + overrides?: CallOverrides + ): Promise< + [number, string, string] & { + callerMode: number; + msgSender: string; + txOrigin: string; + } + >; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record(overrides?: CallOverrides): Promise; + + recordLogs(overrides?: CallOverrides): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resetNonce( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resumeGasMetering(overrides?: CallOverrides): Promise; + + revertTo( + snapshotId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + revertToAndDelete( + snapshotId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "revokePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "revokePersistent(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + roll( + newHeight: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "rollFork(bytes32)"( + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "rollFork(uint256,uint256)"( + forkId: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "rollFork(uint256)"( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "rollFork(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise<[string, string][]>; + + selectFork( + forkId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setNonce( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setNonceUnsafe( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + skip( + skipTest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + snapshot(overrides?: CallOverrides): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"(overrides?: CallOverrides): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + startMappingRecording(overrides?: CallOverrides): Promise; + + "startPrank(address)"( + msgSender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startPrank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + startStateDiffRecording(overrides?: CallOverrides): Promise; + + stopAndReturnStateDiff( + overrides?: CallOverrides + ): Promise; + + stopBroadcast(overrides?: CallOverrides): Promise; + + stopExpectSafeMemory(overrides?: CallOverrides): Promise; + + stopMappingRecording(overrides?: CallOverrides): Promise; + + stopPrank(overrides?: CallOverrides): Promise; + + store( + target: PromiseOrValue, + slot: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "transact(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "transact(bytes32)"( + txHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + txGasPrice( + newGasPrice: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + unixTime(overrides?: CallOverrides): Promise; + + warp( + newTimestamp: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + activeFork(overrides?: CallOverrides): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + allowCheatcodes( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + blobBaseFee( + newBlobBaseFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + blobhashes( + hashes: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + chainId( + newChainId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + clearMockedCalls( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + coinbase( + newCoinbase: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deal( + account: PromiseOrValue, + newBalance: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshot( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshots( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + difficulty( + newDifficulty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + dumpState( + pathToStateJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + etch( + target: PromiseOrValue, + newRuntimeBytecode: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes,uint64)"( + callee: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool,address)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(address)"( + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes4)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemory( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemoryCall( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fee( + newBasefee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlobhashes(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isPersistent( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + loadAllocs( + pathToAllocsJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + account2: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(bytes32)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(uint256)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + readCallers( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resetNonce( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertTo( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertToAndDelete( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + roll( + newHeight: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,uint256)"( + forkId: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256)"( + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise; + + selectFork( + forkId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonce( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonceUnsafe( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + skip( + skipTest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + snapshot( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopExpectSafeMemory( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopPrank( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + store( + target: PromiseOrValue, + slot: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "transact(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "transact(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + txGasPrice( + newGasPrice: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + warp( + newTimestamp: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + activeFork(overrides?: CallOverrides): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + allowCheatcodes( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + blobBaseFee( + newBlobBaseFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + blobhashes( + hashes: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + chainId( + newChainId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + clearMockedCalls( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + coinbase( + newCoinbase: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,uint256)"( + urlOrAlias: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string,bytes32)"( + urlOrAlias: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createSelectFork(string)"( + urlOrAlias: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deal( + account: PromiseOrValue, + newBalance: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshot( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deleteSnapshots( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + difficulty( + newDifficulty: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + dumpState( + pathToStateJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + etch( + target: PromiseOrValue, + newRuntimeBytecode: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + gas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,bytes,uint64)"( + callee: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCall(address,uint256,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectCallMinGas(address,uint256,uint64,bytes,uint64)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + minGas: PromiseOrValue, + data: PromiseOrValue, + count: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(bool,bool,bool,bool,address)"( + checkTopic1: PromiseOrValue, + checkTopic2: PromiseOrValue, + checkTopic3: PromiseOrValue, + checkData: PromiseOrValue, + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectEmit(address)"( + emitter: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes4)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert(bytes)"( + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "expectRevert()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemory( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + expectSafeMemoryCall( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fee( + newBasefee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlobhashes(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isPersistent( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + loadAllocs( + pathToAllocsJson: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "makePersistent(address,address,address)"( + account0: PromiseOrValue, + account1: PromiseOrValue, + account2: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCall(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + returnData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,uint256,bytes,bytes)"( + callee: PromiseOrValue, + msgValue: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "mockCallRevert(address,bytes,bytes)"( + callee: PromiseOrValue, + data: PromiseOrValue, + revertData: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(bytes32)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "prevrandao(uint256)"( + newPrevrandao: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + readCallers( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resetNonce( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertTo( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + revertToAndDelete( + snapshotId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address[])"( + accounts: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "revokePersistent(address)"( + account: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + roll( + newHeight: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,uint256)"( + forkId: PromiseOrValue, + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256)"( + blockNumber: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "rollFork(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise; + + selectFork( + forkId: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonce( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setNonceUnsafe( + account: PromiseOrValue, + newNonce: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + skip( + skipTest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + snapshot( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address)"( + msgSender: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startPrank(address,address)"( + msgSender: PromiseOrValue, + txOrigin: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopExpectSafeMemory( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopPrank( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + store( + target: PromiseOrValue, + slot: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "transact(uint256,bytes32)"( + forkId: PromiseOrValue, + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "transact(bytes32)"( + txHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + txGasPrice( + newGasPrice: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + warp( + newTimestamp: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/Vm.sol/VmSafe.ts b/typechain-types/forge-std/Vm.sol/VmSafe.ts new file mode 100644 index 00000000..728ab080 --- /dev/null +++ b/typechain-types/forge-std/Vm.sol/VmSafe.ts @@ -0,0 +1,13288 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export declare namespace VmSafe { + export type WalletStruct = { + addr: PromiseOrValue; + publicKeyX: PromiseOrValue; + publicKeyY: PromiseOrValue; + privateKey: PromiseOrValue; + }; + + export type WalletStructOutput = [string, BigNumber, BigNumber, BigNumber] & { + addr: string; + publicKeyX: BigNumber; + publicKeyY: BigNumber; + privateKey: BigNumber; + }; + + export type EthGetLogsStruct = { + emitter: PromiseOrValue; + topics: PromiseOrValue[]; + data: PromiseOrValue; + blockHash: PromiseOrValue; + blockNumber: PromiseOrValue; + transactionHash: PromiseOrValue; + transactionIndex: PromiseOrValue; + logIndex: PromiseOrValue; + removed: PromiseOrValue; + }; + + export type EthGetLogsStructOutput = [ + string, + string[], + string, + string, + BigNumber, + string, + BigNumber, + BigNumber, + boolean + ] & { + emitter: string; + topics: string[]; + data: string; + blockHash: string; + blockNumber: BigNumber; + transactionHash: string; + transactionIndex: BigNumber; + logIndex: BigNumber; + removed: boolean; + }; + + export type FsMetadataStruct = { + isDir: PromiseOrValue; + isSymlink: PromiseOrValue; + length: PromiseOrValue; + readOnly: PromiseOrValue; + modified: PromiseOrValue; + accessed: PromiseOrValue; + created: PromiseOrValue; + }; + + export type FsMetadataStructOutput = [ + boolean, + boolean, + BigNumber, + boolean, + BigNumber, + BigNumber, + BigNumber + ] & { + isDir: boolean; + isSymlink: boolean; + length: BigNumber; + readOnly: boolean; + modified: BigNumber; + accessed: BigNumber; + created: BigNumber; + }; + + export type LogStruct = { + topics: PromiseOrValue[]; + data: PromiseOrValue; + emitter: PromiseOrValue; + }; + + export type LogStructOutput = [string[], string, string] & { + topics: string[]; + data: string; + emitter: string; + }; + + export type GasStruct = { + gasLimit: PromiseOrValue; + gasTotalUsed: PromiseOrValue; + gasMemoryUsed: PromiseOrValue; + gasRefunded: PromiseOrValue; + gasRemaining: PromiseOrValue; + }; + + export type GasStructOutput = [ + BigNumber, + BigNumber, + BigNumber, + BigNumber, + BigNumber + ] & { + gasLimit: BigNumber; + gasTotalUsed: BigNumber; + gasMemoryUsed: BigNumber; + gasRefunded: BigNumber; + gasRemaining: BigNumber; + }; + + export type DirEntryStruct = { + errorMessage: PromiseOrValue; + path: PromiseOrValue; + depth: PromiseOrValue; + isDir: PromiseOrValue; + isSymlink: PromiseOrValue; + }; + + export type DirEntryStructOutput = [ + string, + string, + BigNumber, + boolean, + boolean + ] & { + errorMessage: string; + path: string; + depth: BigNumber; + isDir: boolean; + isSymlink: boolean; + }; + + export type RpcStruct = { + key: PromiseOrValue; + url: PromiseOrValue; + }; + + export type RpcStructOutput = [string, string] & { key: string; url: string }; + + export type ChainInfoStruct = { + forkId: PromiseOrValue; + chainId: PromiseOrValue; + }; + + export type ChainInfoStructOutput = [BigNumber, BigNumber] & { + forkId: BigNumber; + chainId: BigNumber; + }; + + export type StorageAccessStruct = { + account: PromiseOrValue; + slot: PromiseOrValue; + isWrite: PromiseOrValue; + previousValue: PromiseOrValue; + newValue: PromiseOrValue; + reverted: PromiseOrValue; + }; + + export type StorageAccessStructOutput = [ + string, + string, + boolean, + string, + string, + boolean + ] & { + account: string; + slot: string; + isWrite: boolean; + previousValue: string; + newValue: string; + reverted: boolean; + }; + + export type AccountAccessStruct = { + chainInfo: VmSafe.ChainInfoStruct; + kind: PromiseOrValue; + account: PromiseOrValue; + accessor: PromiseOrValue; + initialized: PromiseOrValue; + oldBalance: PromiseOrValue; + newBalance: PromiseOrValue; + deployedCode: PromiseOrValue; + value: PromiseOrValue; + data: PromiseOrValue; + reverted: PromiseOrValue; + storageAccesses: VmSafe.StorageAccessStruct[]; + depth: PromiseOrValue; + }; + + export type AccountAccessStructOutput = [ + VmSafe.ChainInfoStructOutput, + number, + string, + string, + boolean, + BigNumber, + BigNumber, + string, + BigNumber, + string, + boolean, + VmSafe.StorageAccessStructOutput[], + BigNumber + ] & { + chainInfo: VmSafe.ChainInfoStructOutput; + kind: number; + account: string; + accessor: string; + initialized: boolean; + oldBalance: BigNumber; + newBalance: BigNumber; + deployedCode: string; + value: BigNumber; + data: string; + reverted: boolean; + storageAccesses: VmSafe.StorageAccessStructOutput[]; + depth: BigNumber; + }; + + export type FfiResultStruct = { + exitCode: PromiseOrValue; + stdout: PromiseOrValue; + stderr: PromiseOrValue; + }; + + export type FfiResultStructOutput = [number, string, string] & { + exitCode: number; + stdout: string; + stderr: string; + }; +} + +export interface VmSafeInterface extends utils.Interface { + functions: { + "accesses(address)": FunctionFragment; + "addr(uint256)": FunctionFragment; + "assertApproxEqAbs(uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbs(int256,int256,uint256)": FunctionFragment; + "assertApproxEqAbs(int256,int256,uint256,string)": FunctionFragment; + "assertApproxEqAbs(uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)": FunctionFragment; + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRel(uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRel(uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqRel(int256,int256,uint256,string)": FunctionFragment; + "assertApproxEqRel(int256,int256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)": FunctionFragment; + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)": FunctionFragment; + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)": FunctionFragment; + "assertEq(bytes32[],bytes32[])": FunctionFragment; + "assertEq(int256[],int256[],string)": FunctionFragment; + "assertEq(address,address,string)": FunctionFragment; + "assertEq(string,string,string)": FunctionFragment; + "assertEq(address[],address[])": FunctionFragment; + "assertEq(address[],address[],string)": FunctionFragment; + "assertEq(bool,bool,string)": FunctionFragment; + "assertEq(address,address)": FunctionFragment; + "assertEq(uint256[],uint256[],string)": FunctionFragment; + "assertEq(bool[],bool[])": FunctionFragment; + "assertEq(int256[],int256[])": FunctionFragment; + "assertEq(int256,int256,string)": FunctionFragment; + "assertEq(bytes32,bytes32)": FunctionFragment; + "assertEq(uint256,uint256,string)": FunctionFragment; + "assertEq(uint256[],uint256[])": FunctionFragment; + "assertEq(bytes,bytes)": FunctionFragment; + "assertEq(uint256,uint256)": FunctionFragment; + "assertEq(bytes32,bytes32,string)": FunctionFragment; + "assertEq(string[],string[])": FunctionFragment; + "assertEq(bytes32[],bytes32[],string)": FunctionFragment; + "assertEq(bytes,bytes,string)": FunctionFragment; + "assertEq(bool[],bool[],string)": FunctionFragment; + "assertEq(bytes[],bytes[])": FunctionFragment; + "assertEq(string[],string[],string)": FunctionFragment; + "assertEq(string,string)": FunctionFragment; + "assertEq(bytes[],bytes[],string)": FunctionFragment; + "assertEq(bool,bool)": FunctionFragment; + "assertEq(int256,int256)": FunctionFragment; + "assertEqDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertEqDecimal(int256,int256,uint256)": FunctionFragment; + "assertEqDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertEqDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertFalse(bool,string)": FunctionFragment; + "assertFalse(bool)": FunctionFragment; + "assertGe(int256,int256)": FunctionFragment; + "assertGe(int256,int256,string)": FunctionFragment; + "assertGe(uint256,uint256)": FunctionFragment; + "assertGe(uint256,uint256,string)": FunctionFragment; + "assertGeDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertGeDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertGeDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertGeDecimal(int256,int256,uint256)": FunctionFragment; + "assertGt(int256,int256)": FunctionFragment; + "assertGt(uint256,uint256,string)": FunctionFragment; + "assertGt(uint256,uint256)": FunctionFragment; + "assertGt(int256,int256,string)": FunctionFragment; + "assertGtDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertGtDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertGtDecimal(int256,int256,uint256)": FunctionFragment; + "assertGtDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLe(int256,int256,string)": FunctionFragment; + "assertLe(uint256,uint256)": FunctionFragment; + "assertLe(int256,int256)": FunctionFragment; + "assertLe(uint256,uint256,string)": FunctionFragment; + "assertLeDecimal(int256,int256,uint256)": FunctionFragment; + "assertLeDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertLeDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertLeDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLt(int256,int256)": FunctionFragment; + "assertLt(uint256,uint256,string)": FunctionFragment; + "assertLt(int256,int256,string)": FunctionFragment; + "assertLt(uint256,uint256)": FunctionFragment; + "assertLtDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertLtDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertLtDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertLtDecimal(int256,int256,uint256)": FunctionFragment; + "assertNotEq(bytes32[],bytes32[])": FunctionFragment; + "assertNotEq(int256[],int256[])": FunctionFragment; + "assertNotEq(bool,bool,string)": FunctionFragment; + "assertNotEq(bytes[],bytes[],string)": FunctionFragment; + "assertNotEq(bool,bool)": FunctionFragment; + "assertNotEq(bool[],bool[])": FunctionFragment; + "assertNotEq(bytes,bytes)": FunctionFragment; + "assertNotEq(address[],address[])": FunctionFragment; + "assertNotEq(int256,int256,string)": FunctionFragment; + "assertNotEq(uint256[],uint256[])": FunctionFragment; + "assertNotEq(bool[],bool[],string)": FunctionFragment; + "assertNotEq(string,string)": FunctionFragment; + "assertNotEq(address[],address[],string)": FunctionFragment; + "assertNotEq(string,string,string)": FunctionFragment; + "assertNotEq(address,address,string)": FunctionFragment; + "assertNotEq(bytes32,bytes32)": FunctionFragment; + "assertNotEq(bytes,bytes,string)": FunctionFragment; + "assertNotEq(uint256,uint256,string)": FunctionFragment; + "assertNotEq(uint256[],uint256[],string)": FunctionFragment; + "assertNotEq(address,address)": FunctionFragment; + "assertNotEq(bytes32,bytes32,string)": FunctionFragment; + "assertNotEq(string[],string[],string)": FunctionFragment; + "assertNotEq(uint256,uint256)": FunctionFragment; + "assertNotEq(bytes32[],bytes32[],string)": FunctionFragment; + "assertNotEq(string[],string[])": FunctionFragment; + "assertNotEq(int256[],int256[],string)": FunctionFragment; + "assertNotEq(bytes[],bytes[])": FunctionFragment; + "assertNotEq(int256,int256)": FunctionFragment; + "assertNotEqDecimal(int256,int256,uint256)": FunctionFragment; + "assertNotEqDecimal(int256,int256,uint256,string)": FunctionFragment; + "assertNotEqDecimal(uint256,uint256,uint256)": FunctionFragment; + "assertNotEqDecimal(uint256,uint256,uint256,string)": FunctionFragment; + "assertTrue(bool)": FunctionFragment; + "assertTrue(bool,string)": FunctionFragment; + "assume(bool)": FunctionFragment; + "breakpoint(string)": FunctionFragment; + "breakpoint(string,bool)": FunctionFragment; + "broadcast()": FunctionFragment; + "broadcast(address)": FunctionFragment; + "broadcast(uint256)": FunctionFragment; + "closeFile(string)": FunctionFragment; + "computeCreate2Address(bytes32,bytes32)": FunctionFragment; + "computeCreate2Address(bytes32,bytes32,address)": FunctionFragment; + "computeCreateAddress(address,uint256)": FunctionFragment; + "copyFile(string,string)": FunctionFragment; + "createDir(string,bool)": FunctionFragment; + "createWallet(string)": FunctionFragment; + "createWallet(uint256)": FunctionFragment; + "createWallet(uint256,string)": FunctionFragment; + "deriveKey(string,string,uint32,string)": FunctionFragment; + "deriveKey(string,uint32,string)": FunctionFragment; + "deriveKey(string,uint32)": FunctionFragment; + "deriveKey(string,string,uint32)": FunctionFragment; + "ensNamehash(string)": FunctionFragment; + "envAddress(string)": FunctionFragment; + "envAddress(string,string)": FunctionFragment; + "envBool(string)": FunctionFragment; + "envBool(string,string)": FunctionFragment; + "envBytes(string)": FunctionFragment; + "envBytes(string,string)": FunctionFragment; + "envBytes32(string,string)": FunctionFragment; + "envBytes32(string)": FunctionFragment; + "envExists(string)": FunctionFragment; + "envInt(string,string)": FunctionFragment; + "envInt(string)": FunctionFragment; + "envOr(string,string,bytes32[])": FunctionFragment; + "envOr(string,string,int256[])": FunctionFragment; + "envOr(string,bool)": FunctionFragment; + "envOr(string,address)": FunctionFragment; + "envOr(string,uint256)": FunctionFragment; + "envOr(string,string,bytes[])": FunctionFragment; + "envOr(string,string,uint256[])": FunctionFragment; + "envOr(string,string,string[])": FunctionFragment; + "envOr(string,bytes)": FunctionFragment; + "envOr(string,bytes32)": FunctionFragment; + "envOr(string,int256)": FunctionFragment; + "envOr(string,string,address[])": FunctionFragment; + "envOr(string,string)": FunctionFragment; + "envOr(string,string,bool[])": FunctionFragment; + "envString(string,string)": FunctionFragment; + "envString(string)": FunctionFragment; + "envUint(string)": FunctionFragment; + "envUint(string,string)": FunctionFragment; + "eth_getLogs(uint256,uint256,address,bytes32[])": FunctionFragment; + "exists(string)": FunctionFragment; + "ffi(string[])": FunctionFragment; + "fsMetadata(string)": FunctionFragment; + "getBlobBaseFee()": FunctionFragment; + "getBlockNumber()": FunctionFragment; + "getBlockTimestamp()": FunctionFragment; + "getCode(string)": FunctionFragment; + "getDeployedCode(string)": FunctionFragment; + "getLabel(address)": FunctionFragment; + "getMappingKeyAndParentOf(address,bytes32)": FunctionFragment; + "getMappingLength(address,bytes32)": FunctionFragment; + "getMappingSlotAt(address,bytes32,uint256)": FunctionFragment; + "getNonce(address)": FunctionFragment; + "getNonce((address,uint256,uint256,uint256))": FunctionFragment; + "getRecordedLogs()": FunctionFragment; + "indexOf(string,string)": FunctionFragment; + "isContext(uint8)": FunctionFragment; + "isDir(string)": FunctionFragment; + "isFile(string)": FunctionFragment; + "keyExists(string,string)": FunctionFragment; + "keyExistsJson(string,string)": FunctionFragment; + "keyExistsToml(string,string)": FunctionFragment; + "label(address,string)": FunctionFragment; + "lastCallGas()": FunctionFragment; + "load(address,bytes32)": FunctionFragment; + "parseAddress(string)": FunctionFragment; + "parseBool(string)": FunctionFragment; + "parseBytes(string)": FunctionFragment; + "parseBytes32(string)": FunctionFragment; + "parseInt(string)": FunctionFragment; + "parseJson(string)": FunctionFragment; + "parseJson(string,string)": FunctionFragment; + "parseJsonAddress(string,string)": FunctionFragment; + "parseJsonAddressArray(string,string)": FunctionFragment; + "parseJsonBool(string,string)": FunctionFragment; + "parseJsonBoolArray(string,string)": FunctionFragment; + "parseJsonBytes(string,string)": FunctionFragment; + "parseJsonBytes32(string,string)": FunctionFragment; + "parseJsonBytes32Array(string,string)": FunctionFragment; + "parseJsonBytesArray(string,string)": FunctionFragment; + "parseJsonInt(string,string)": FunctionFragment; + "parseJsonIntArray(string,string)": FunctionFragment; + "parseJsonKeys(string,string)": FunctionFragment; + "parseJsonString(string,string)": FunctionFragment; + "parseJsonStringArray(string,string)": FunctionFragment; + "parseJsonUint(string,string)": FunctionFragment; + "parseJsonUintArray(string,string)": FunctionFragment; + "parseToml(string,string)": FunctionFragment; + "parseToml(string)": FunctionFragment; + "parseTomlAddress(string,string)": FunctionFragment; + "parseTomlAddressArray(string,string)": FunctionFragment; + "parseTomlBool(string,string)": FunctionFragment; + "parseTomlBoolArray(string,string)": FunctionFragment; + "parseTomlBytes(string,string)": FunctionFragment; + "parseTomlBytes32(string,string)": FunctionFragment; + "parseTomlBytes32Array(string,string)": FunctionFragment; + "parseTomlBytesArray(string,string)": FunctionFragment; + "parseTomlInt(string,string)": FunctionFragment; + "parseTomlIntArray(string,string)": FunctionFragment; + "parseTomlKeys(string,string)": FunctionFragment; + "parseTomlString(string,string)": FunctionFragment; + "parseTomlStringArray(string,string)": FunctionFragment; + "parseTomlUint(string,string)": FunctionFragment; + "parseTomlUintArray(string,string)": FunctionFragment; + "parseUint(string)": FunctionFragment; + "pauseGasMetering()": FunctionFragment; + "projectRoot()": FunctionFragment; + "prompt(string)": FunctionFragment; + "promptAddress(string)": FunctionFragment; + "promptSecret(string)": FunctionFragment; + "promptSecretUint(string)": FunctionFragment; + "promptUint(string)": FunctionFragment; + "randomAddress()": FunctionFragment; + "randomUint()": FunctionFragment; + "randomUint(uint256,uint256)": FunctionFragment; + "readDir(string,uint64)": FunctionFragment; + "readDir(string,uint64,bool)": FunctionFragment; + "readDir(string)": FunctionFragment; + "readFile(string)": FunctionFragment; + "readFileBinary(string)": FunctionFragment; + "readLine(string)": FunctionFragment; + "readLink(string)": FunctionFragment; + "record()": FunctionFragment; + "recordLogs()": FunctionFragment; + "rememberKey(uint256)": FunctionFragment; + "removeDir(string,bool)": FunctionFragment; + "removeFile(string)": FunctionFragment; + "replace(string,string,string)": FunctionFragment; + "resumeGasMetering()": FunctionFragment; + "rpc(string,string)": FunctionFragment; + "rpcUrl(string)": FunctionFragment; + "rpcUrlStructs()": FunctionFragment; + "rpcUrls()": FunctionFragment; + "serializeAddress(string,string,address[])": FunctionFragment; + "serializeAddress(string,string,address)": FunctionFragment; + "serializeBool(string,string,bool[])": FunctionFragment; + "serializeBool(string,string,bool)": FunctionFragment; + "serializeBytes(string,string,bytes[])": FunctionFragment; + "serializeBytes(string,string,bytes)": FunctionFragment; + "serializeBytes32(string,string,bytes32[])": FunctionFragment; + "serializeBytes32(string,string,bytes32)": FunctionFragment; + "serializeInt(string,string,int256)": FunctionFragment; + "serializeInt(string,string,int256[])": FunctionFragment; + "serializeJson(string,string)": FunctionFragment; + "serializeString(string,string,string[])": FunctionFragment; + "serializeString(string,string,string)": FunctionFragment; + "serializeUint(string,string,uint256)": FunctionFragment; + "serializeUint(string,string,uint256[])": FunctionFragment; + "serializeUintToHex(string,string,uint256)": FunctionFragment; + "setEnv(string,string)": FunctionFragment; + "sign(bytes32)": FunctionFragment; + "sign(address,bytes32)": FunctionFragment; + "sign((address,uint256,uint256,uint256),bytes32)": FunctionFragment; + "sign(uint256,bytes32)": FunctionFragment; + "signP256(uint256,bytes32)": FunctionFragment; + "sleep(uint256)": FunctionFragment; + "split(string,string)": FunctionFragment; + "startBroadcast()": FunctionFragment; + "startBroadcast(address)": FunctionFragment; + "startBroadcast(uint256)": FunctionFragment; + "startMappingRecording()": FunctionFragment; + "startStateDiffRecording()": FunctionFragment; + "stopAndReturnStateDiff()": FunctionFragment; + "stopBroadcast()": FunctionFragment; + "stopMappingRecording()": FunctionFragment; + "toBase64(string)": FunctionFragment; + "toBase64(bytes)": FunctionFragment; + "toBase64URL(string)": FunctionFragment; + "toBase64URL(bytes)": FunctionFragment; + "toLowercase(string)": FunctionFragment; + "toString(address)": FunctionFragment; + "toString(uint256)": FunctionFragment; + "toString(bytes)": FunctionFragment; + "toString(bool)": FunctionFragment; + "toString(int256)": FunctionFragment; + "toString(bytes32)": FunctionFragment; + "toUppercase(string)": FunctionFragment; + "trim(string)": FunctionFragment; + "tryFfi(string[])": FunctionFragment; + "unixTime()": FunctionFragment; + "writeFile(string,string)": FunctionFragment; + "writeFileBinary(string,bytes)": FunctionFragment; + "writeJson(string,string,string)": FunctionFragment; + "writeJson(string,string)": FunctionFragment; + "writeLine(string,string)": FunctionFragment; + "writeToml(string,string,string)": FunctionFragment; + "writeToml(string,string)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "accesses" + | "addr" + | "assertApproxEqAbs(uint256,uint256,uint256)" + | "assertApproxEqAbs(int256,int256,uint256)" + | "assertApproxEqAbs(int256,int256,uint256,string)" + | "assertApproxEqAbs(uint256,uint256,uint256,string)" + | "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)" + | "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)" + | "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)" + | "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)" + | "assertApproxEqRel(uint256,uint256,uint256,string)" + | "assertApproxEqRel(uint256,uint256,uint256)" + | "assertApproxEqRel(int256,int256,uint256,string)" + | "assertApproxEqRel(int256,int256,uint256)" + | "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)" + | "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)" + | "assertApproxEqRelDecimal(int256,int256,uint256,uint256)" + | "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)" + | "assertEq(bytes32[],bytes32[])" + | "assertEq(int256[],int256[],string)" + | "assertEq(address,address,string)" + | "assertEq(string,string,string)" + | "assertEq(address[],address[])" + | "assertEq(address[],address[],string)" + | "assertEq(bool,bool,string)" + | "assertEq(address,address)" + | "assertEq(uint256[],uint256[],string)" + | "assertEq(bool[],bool[])" + | "assertEq(int256[],int256[])" + | "assertEq(int256,int256,string)" + | "assertEq(bytes32,bytes32)" + | "assertEq(uint256,uint256,string)" + | "assertEq(uint256[],uint256[])" + | "assertEq(bytes,bytes)" + | "assertEq(uint256,uint256)" + | "assertEq(bytes32,bytes32,string)" + | "assertEq(string[],string[])" + | "assertEq(bytes32[],bytes32[],string)" + | "assertEq(bytes,bytes,string)" + | "assertEq(bool[],bool[],string)" + | "assertEq(bytes[],bytes[])" + | "assertEq(string[],string[],string)" + | "assertEq(string,string)" + | "assertEq(bytes[],bytes[],string)" + | "assertEq(bool,bool)" + | "assertEq(int256,int256)" + | "assertEqDecimal(uint256,uint256,uint256)" + | "assertEqDecimal(int256,int256,uint256)" + | "assertEqDecimal(int256,int256,uint256,string)" + | "assertEqDecimal(uint256,uint256,uint256,string)" + | "assertFalse(bool,string)" + | "assertFalse(bool)" + | "assertGe(int256,int256)" + | "assertGe(int256,int256,string)" + | "assertGe(uint256,uint256)" + | "assertGe(uint256,uint256,string)" + | "assertGeDecimal(uint256,uint256,uint256)" + | "assertGeDecimal(int256,int256,uint256,string)" + | "assertGeDecimal(uint256,uint256,uint256,string)" + | "assertGeDecimal(int256,int256,uint256)" + | "assertGt(int256,int256)" + | "assertGt(uint256,uint256,string)" + | "assertGt(uint256,uint256)" + | "assertGt(int256,int256,string)" + | "assertGtDecimal(int256,int256,uint256,string)" + | "assertGtDecimal(uint256,uint256,uint256,string)" + | "assertGtDecimal(int256,int256,uint256)" + | "assertGtDecimal(uint256,uint256,uint256)" + | "assertLe(int256,int256,string)" + | "assertLe(uint256,uint256)" + | "assertLe(int256,int256)" + | "assertLe(uint256,uint256,string)" + | "assertLeDecimal(int256,int256,uint256)" + | "assertLeDecimal(uint256,uint256,uint256,string)" + | "assertLeDecimal(int256,int256,uint256,string)" + | "assertLeDecimal(uint256,uint256,uint256)" + | "assertLt(int256,int256)" + | "assertLt(uint256,uint256,string)" + | "assertLt(int256,int256,string)" + | "assertLt(uint256,uint256)" + | "assertLtDecimal(uint256,uint256,uint256)" + | "assertLtDecimal(int256,int256,uint256,string)" + | "assertLtDecimal(uint256,uint256,uint256,string)" + | "assertLtDecimal(int256,int256,uint256)" + | "assertNotEq(bytes32[],bytes32[])" + | "assertNotEq(int256[],int256[])" + | "assertNotEq(bool,bool,string)" + | "assertNotEq(bytes[],bytes[],string)" + | "assertNotEq(bool,bool)" + | "assertNotEq(bool[],bool[])" + | "assertNotEq(bytes,bytes)" + | "assertNotEq(address[],address[])" + | "assertNotEq(int256,int256,string)" + | "assertNotEq(uint256[],uint256[])" + | "assertNotEq(bool[],bool[],string)" + | "assertNotEq(string,string)" + | "assertNotEq(address[],address[],string)" + | "assertNotEq(string,string,string)" + | "assertNotEq(address,address,string)" + | "assertNotEq(bytes32,bytes32)" + | "assertNotEq(bytes,bytes,string)" + | "assertNotEq(uint256,uint256,string)" + | "assertNotEq(uint256[],uint256[],string)" + | "assertNotEq(address,address)" + | "assertNotEq(bytes32,bytes32,string)" + | "assertNotEq(string[],string[],string)" + | "assertNotEq(uint256,uint256)" + | "assertNotEq(bytes32[],bytes32[],string)" + | "assertNotEq(string[],string[])" + | "assertNotEq(int256[],int256[],string)" + | "assertNotEq(bytes[],bytes[])" + | "assertNotEq(int256,int256)" + | "assertNotEqDecimal(int256,int256,uint256)" + | "assertNotEqDecimal(int256,int256,uint256,string)" + | "assertNotEqDecimal(uint256,uint256,uint256)" + | "assertNotEqDecimal(uint256,uint256,uint256,string)" + | "assertTrue(bool)" + | "assertTrue(bool,string)" + | "assume" + | "breakpoint(string)" + | "breakpoint(string,bool)" + | "broadcast()" + | "broadcast(address)" + | "broadcast(uint256)" + | "closeFile" + | "computeCreate2Address(bytes32,bytes32)" + | "computeCreate2Address(bytes32,bytes32,address)" + | "computeCreateAddress" + | "copyFile" + | "createDir" + | "createWallet(string)" + | "createWallet(uint256)" + | "createWallet(uint256,string)" + | "deriveKey(string,string,uint32,string)" + | "deriveKey(string,uint32,string)" + | "deriveKey(string,uint32)" + | "deriveKey(string,string,uint32)" + | "ensNamehash" + | "envAddress(string)" + | "envAddress(string,string)" + | "envBool(string)" + | "envBool(string,string)" + | "envBytes(string)" + | "envBytes(string,string)" + | "envBytes32(string,string)" + | "envBytes32(string)" + | "envExists" + | "envInt(string,string)" + | "envInt(string)" + | "envOr(string,string,bytes32[])" + | "envOr(string,string,int256[])" + | "envOr(string,bool)" + | "envOr(string,address)" + | "envOr(string,uint256)" + | "envOr(string,string,bytes[])" + | "envOr(string,string,uint256[])" + | "envOr(string,string,string[])" + | "envOr(string,bytes)" + | "envOr(string,bytes32)" + | "envOr(string,int256)" + | "envOr(string,string,address[])" + | "envOr(string,string)" + | "envOr(string,string,bool[])" + | "envString(string,string)" + | "envString(string)" + | "envUint(string)" + | "envUint(string,string)" + | "eth_getLogs" + | "exists" + | "ffi" + | "fsMetadata" + | "getBlobBaseFee" + | "getBlockNumber" + | "getBlockTimestamp" + | "getCode" + | "getDeployedCode" + | "getLabel" + | "getMappingKeyAndParentOf" + | "getMappingLength" + | "getMappingSlotAt" + | "getNonce(address)" + | "getNonce((address,uint256,uint256,uint256))" + | "getRecordedLogs" + | "indexOf" + | "isContext" + | "isDir" + | "isFile" + | "keyExists" + | "keyExistsJson" + | "keyExistsToml" + | "label" + | "lastCallGas" + | "load" + | "parseAddress" + | "parseBool" + | "parseBytes" + | "parseBytes32" + | "parseInt" + | "parseJson(string)" + | "parseJson(string,string)" + | "parseJsonAddress" + | "parseJsonAddressArray" + | "parseJsonBool" + | "parseJsonBoolArray" + | "parseJsonBytes" + | "parseJsonBytes32" + | "parseJsonBytes32Array" + | "parseJsonBytesArray" + | "parseJsonInt" + | "parseJsonIntArray" + | "parseJsonKeys" + | "parseJsonString" + | "parseJsonStringArray" + | "parseJsonUint" + | "parseJsonUintArray" + | "parseToml(string,string)" + | "parseToml(string)" + | "parseTomlAddress" + | "parseTomlAddressArray" + | "parseTomlBool" + | "parseTomlBoolArray" + | "parseTomlBytes" + | "parseTomlBytes32" + | "parseTomlBytes32Array" + | "parseTomlBytesArray" + | "parseTomlInt" + | "parseTomlIntArray" + | "parseTomlKeys" + | "parseTomlString" + | "parseTomlStringArray" + | "parseTomlUint" + | "parseTomlUintArray" + | "parseUint" + | "pauseGasMetering" + | "projectRoot" + | "prompt" + | "promptAddress" + | "promptSecret" + | "promptSecretUint" + | "promptUint" + | "randomAddress" + | "randomUint()" + | "randomUint(uint256,uint256)" + | "readDir(string,uint64)" + | "readDir(string,uint64,bool)" + | "readDir(string)" + | "readFile" + | "readFileBinary" + | "readLine" + | "readLink" + | "record" + | "recordLogs" + | "rememberKey" + | "removeDir" + | "removeFile" + | "replace" + | "resumeGasMetering" + | "rpc" + | "rpcUrl" + | "rpcUrlStructs" + | "rpcUrls" + | "serializeAddress(string,string,address[])" + | "serializeAddress(string,string,address)" + | "serializeBool(string,string,bool[])" + | "serializeBool(string,string,bool)" + | "serializeBytes(string,string,bytes[])" + | "serializeBytes(string,string,bytes)" + | "serializeBytes32(string,string,bytes32[])" + | "serializeBytes32(string,string,bytes32)" + | "serializeInt(string,string,int256)" + | "serializeInt(string,string,int256[])" + | "serializeJson" + | "serializeString(string,string,string[])" + | "serializeString(string,string,string)" + | "serializeUint(string,string,uint256)" + | "serializeUint(string,string,uint256[])" + | "serializeUintToHex" + | "setEnv" + | "sign(bytes32)" + | "sign(address,bytes32)" + | "sign((address,uint256,uint256,uint256),bytes32)" + | "sign(uint256,bytes32)" + | "signP256" + | "sleep" + | "split" + | "startBroadcast()" + | "startBroadcast(address)" + | "startBroadcast(uint256)" + | "startMappingRecording" + | "startStateDiffRecording" + | "stopAndReturnStateDiff" + | "stopBroadcast" + | "stopMappingRecording" + | "toBase64(string)" + | "toBase64(bytes)" + | "toBase64URL(string)" + | "toBase64URL(bytes)" + | "toLowercase" + | "toString(address)" + | "toString(uint256)" + | "toString(bytes)" + | "toString(bool)" + | "toString(int256)" + | "toString(bytes32)" + | "toUppercase" + | "trim" + | "tryFfi" + | "unixTime" + | "writeFile" + | "writeFileBinary" + | "writeJson(string,string,string)" + | "writeJson(string,string)" + | "writeLine" + | "writeToml(string,string,string)" + | "writeToml(string,string)" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "accesses", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "addr", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRel(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32[],bytes32[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256[],int256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address,address,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address[],address[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address[],address[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool,bool,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256[],uint256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool[],bool[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256[],int256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256[],uint256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32,bytes32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string[],string[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes32[],bytes32[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes,bytes,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool[],bool[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes[],bytes[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string[],string[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bytes[],bytes[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEq(bool,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEq(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertEqDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertFalse(bool,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertFalse(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGe(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGe(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGeDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGt(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGt(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGt(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertGt(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertGtDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLe(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLe(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLe(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLe(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLeDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLt(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLt(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertLtDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32[],bytes32[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256[],int256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool,bool,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes[],bytes[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool[],bool[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address[],address[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256,int256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256[],uint256[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bool[],bool[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address[],address[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address,address,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes,bytes,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256[],uint256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(address,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32,bytes32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string[],string[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes32[],bytes32[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(string[],string[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256[],int256[],string)", + values: [ + PromiseOrValue[], + PromiseOrValue[], + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(bytes[],bytes[])", + values: [PromiseOrValue[], PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "assertNotEq(int256,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(int256,int256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(int256,int256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "assertTrue(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assertTrue(bool,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "assume", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "breakpoint(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "breakpoint(string,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "broadcast()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "broadcast(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "broadcast(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "closeFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "computeCreate2Address(bytes32,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "computeCreate2Address(bytes32,bytes32,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "computeCreateAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "copyFile", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createDir", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "createWallet(uint256,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,string,uint32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,uint32,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,uint32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deriveKey(string,string,uint32)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "ensNamehash", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envAddress(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envAddress(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBool(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBool(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes32(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envBytes32(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envExists", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envInt(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envInt(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bytes32[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,int256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bool)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,address)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bytes[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,uint256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,string[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,int256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,address[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envOr(string,string,bool[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "envString(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envString(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envUint(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "envUint(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "eth_getLogs", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "exists", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "ffi", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData( + functionFragment: "fsMetadata", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getBlobBaseFee", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlockNumber", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlockTimestamp", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCode", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getDeployedCode", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getLabel", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingKeyAndParentOf", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingLength", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getMappingSlotAt", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "getNonce(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getNonce((address,uint256,uint256,uint256))", + values: [VmSafe.WalletStruct] + ): string; + encodeFunctionData( + functionFragment: "getRecordedLogs", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "indexOf", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isContext", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isDir", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExists", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExistsJson", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "keyExistsToml", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "label", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "lastCallGas", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "load", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBool", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBytes", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseBytes32", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseInt", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJson(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJson(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonAddressArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBool", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBoolArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes32", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytes32Array", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonBytesArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonInt", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonIntArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonKeys", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonString", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonStringArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonUint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseJsonUintArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseToml(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseToml(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlAddress", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlAddressArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBool", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBoolArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes32", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytes32Array", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlBytesArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlInt", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlIntArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlKeys", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlString", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlStringArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlUint", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseTomlUintArray", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "parseUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "pauseGasMetering", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "projectRoot", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "prompt", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptSecret", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptSecretUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "promptUint", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "randomAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "randomUint()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "randomUint(uint256,uint256)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readDir(string,uint64)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readDir(string,uint64,bool)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "readDir(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readFileBinary", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readLine", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "readLink", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "record", values?: undefined): string; + encodeFunctionData( + functionFragment: "recordLogs", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rememberKey", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "removeDir", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "removeFile", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "replace", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "resumeGasMetering", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "rpc", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rpcUrl", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "rpcUrlStructs", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "rpcUrls", values?: undefined): string; + encodeFunctionData( + functionFragment: "serializeAddress(string,string,address[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeAddress(string,string,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBool(string,string,bool[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBool(string,string,bool)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes(string,string,bytes[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes(string,string,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes32(string,string,bytes32[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeBytes32(string,string,bytes32)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeInt(string,string,int256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeInt(string,string,int256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeJson", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "serializeString(string,string,string[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeString(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUint(string,string,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUint(string,string,uint256[])", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue[] + ] + ): string; + encodeFunctionData( + functionFragment: "serializeUintToHex", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setEnv", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(address,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign((address,uint256,uint256,uint256),bytes32)", + values: [VmSafe.WalletStruct, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sign(uint256,bytes32)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "signP256", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "sleep", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "split", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startBroadcast()", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "startBroadcast(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startBroadcast(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "startMappingRecording", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "startStateDiffRecording", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopAndReturnStateDiff", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopBroadcast", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "stopMappingRecording", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "toBase64(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64URL(string)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toBase64URL(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toLowercase", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bytes)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bool)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(int256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toString(bytes32)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "toUppercase", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "trim", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tryFfi", + values: [PromiseOrValue[]] + ): string; + encodeFunctionData(functionFragment: "unixTime", values?: undefined): string; + encodeFunctionData( + functionFragment: "writeFile", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeFileBinary", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeJson(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "writeJson(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeLine", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "writeToml(string,string,string)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "writeToml(string,string)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + + decodeFunctionResult(functionFragment: "accesses", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "addr", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbs(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRel(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32[],bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256[],int256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address,address,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address[],address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address[],address[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool,bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256[],uint256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool[],bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256[],int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256[],uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32,bytes32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string[],string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes32[],bytes32[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes,bytes,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool[],bool[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes[],bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string[],string[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bytes[],bytes[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(bool,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEq(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertEqDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertFalse(bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertFalse(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGe(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGeDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGt(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertGtDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLe(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLeDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLt(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertLtDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32[],bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256[],int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool,bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes[],bytes[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool[],bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address[],address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256,int256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256[],uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bool[],bool[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address[],address[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address,address,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes,bytes,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256[],uint256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(address,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32,bytes32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string[],string[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes32[],bytes32[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(string[],string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256[],int256[],string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(bytes[],bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEq(int256,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(int256,int256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(int256,int256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertNotEqDecimal(uint256,uint256,uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertTrue(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "assertTrue(bool,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "assume", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "breakpoint(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "breakpoint(string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "broadcast(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "closeFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "computeCreate2Address(bytes32,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "computeCreate2Address(bytes32,bytes32,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "computeCreateAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "copyFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "createDir", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "createWallet(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createWallet(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "createWallet(uint256,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,string,uint32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,uint32,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,uint32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deriveKey(string,string,uint32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "ensNamehash", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envAddress(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envAddress(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBool(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBool(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes32(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envBytes32(string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "envExists", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "envInt(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envInt(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envOr(string,string,bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envString(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envString(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envUint(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "envUint(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "eth_getLogs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "exists", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "ffi", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "fsMetadata", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getBlobBaseFee", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlockNumber", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlockTimestamp", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getCode", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getDeployedCode", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getLabel", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getMappingKeyAndParentOf", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMappingLength", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getMappingSlotAt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getNonce(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getNonce((address,uint256,uint256,uint256))", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getRecordedLogs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "indexOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isContext", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isDir", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "isFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "keyExists", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "keyExistsJson", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "keyExistsToml", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "label", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "lastCallGas", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "load", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "parseAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseBool", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "parseBytes", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "parseBytes32", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseInt", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "parseJson(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJson(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonAddressArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBool", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBoolArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes32", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytes32Array", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonBytesArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonInt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonIntArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonKeys", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonString", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonStringArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonUint", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseJsonUintArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseToml(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseToml(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlAddressArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBool", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBoolArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes32", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytes32Array", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlBytesArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlInt", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlIntArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlKeys", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlString", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlStringArray", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlUint", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "parseTomlUintArray", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "parseUint", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "pauseGasMetering", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "projectRoot", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "prompt", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "promptAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "promptSecret", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "promptSecretUint", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "promptUint", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "randomAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "randomUint()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "randomUint(uint256,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string,uint64)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string,uint64,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "readDir(string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "readFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "readFileBinary", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "readLine", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "readLink", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "record", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "recordLogs", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rememberKey", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "removeDir", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "removeFile", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "replace", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "resumeGasMetering", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "rpc", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "rpcUrl", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "rpcUrlStructs", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "rpcUrls", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "serializeAddress(string,string,address[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeAddress(string,string,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBool(string,string,bool[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBool(string,string,bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes(string,string,bytes[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes(string,string,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes32(string,string,bytes32[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeBytes32(string,string,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeInt(string,string,int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeInt(string,string,int256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeJson", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeString(string,string,string[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeString(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUint(string,string,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUint(string,string,uint256[])", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "serializeUintToHex", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "setEnv", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "sign(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign(address,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign((address,uint256,uint256,uint256),bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "sign(uint256,bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "signP256", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "sleep", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "split", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "startBroadcast()", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startBroadcast(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startBroadcast(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startMappingRecording", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "startStateDiffRecording", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopAndReturnStateDiff", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopBroadcast", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "stopMappingRecording", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64URL(string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toBase64URL(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toLowercase", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bool)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(int256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toString(bytes32)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "toUppercase", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "trim", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "tryFfi", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "unixTime", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "writeFile", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "writeFileBinary", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeJson(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeJson(string,string)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "writeLine", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "writeToml(string,string,string)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "writeToml(string,string)", + data: BytesLike + ): Result; + + events: {}; +} + +export interface VmSafe extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: VmSafeInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { keyAddr: string }>; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[void]>; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { privateKey: BigNumber }>; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { value: boolean }>; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]] & { value: boolean[] }>; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { result: boolean }>; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { value: boolean }>; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise<[boolean[]] & { value: boolean[] }>; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { value: string[] }>; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { value: string }>; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { value: BigNumber }>; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]] & { value: BigNumber[] }>; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.FsMetadataStructOutput] & { + metadata: VmSafe.FsMetadataStructOutput; + } + >; + + getBlobBaseFee( + overrides?: CallOverrides + ): Promise<[BigNumber] & { blobBaseFee: BigNumber }>; + + getBlockNumber( + overrides?: CallOverrides + ): Promise<[BigNumber] & { height: BigNumber }>; + + getBlockTimestamp( + overrides?: CallOverrides + ): Promise<[BigNumber] & { timestamp: BigNumber }>; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { creationBytecode: string }>; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { runtimeBytecode: string }>; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { currentLabel: string }>; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { nonce: BigNumber }>; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { result: boolean }>; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas( + overrides?: CallOverrides + ): Promise<[VmSafe.GasStructOutput] & { gas: VmSafe.GasStructOutput }>; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean] & { parsedValue: boolean }>; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { parsedValue: string }>; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { parsedValue: BigNumber }>; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]]>; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { keys: string[] }>; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { abiEncodedData: string }>; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean[]]>; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { keys: string[] }>; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]]>; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber[]]>; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { parsedValue: BigNumber }>; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot( + overrides?: CallOverrides + ): Promise<[string] & { path: string }>; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [VmSafe.DirEntryStructOutput[]] & { + entries: VmSafe.DirEntryStructOutput[]; + } + >; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { data: string }>; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { line: string }>; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { targetPath: string }>; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { json: string }>; + + rpcUrlStructs( + overrides?: CallOverrides + ): Promise<[VmSafe.RpcStructOutput[]] & { urls: VmSafe.RpcStructOutput[] }>; + + rpcUrls( + overrides?: CallOverrides + ): Promise<[[string, string][]] & { urls: [string, string][] }>; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string[]] & { outputs: string[] }>; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { stringifiedValue: string }>; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { output: string }>; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise<[string, string][]>; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + accesses( + target: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [string[], string[]] & { readSlots: string[]; writeSlots: string[] } + >; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "broadcast()"(overrides?: CallOverrides): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: CallOverrides + ): Promise< + [boolean, string, string] & { + found: boolean; + key: string; + parent: string; + } + >; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: CallOverrides + ): Promise; + + getRecordedLogs( + overrides?: CallOverrides + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering(overrides?: CallOverrides): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + randomAddress(overrides?: CallOverrides): Promise; + + "randomUint()"(overrides?: CallOverrides): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record(overrides?: CallOverrides): Promise; + + recordLogs(overrides?: CallOverrides): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resumeGasMetering(overrides?: CallOverrides): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise<[string, string][]>; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[number, string, string] & { v: number; r: string; s: string }>; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string, string] & { r: string; s: string }>; + + sleep( + duration: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"(overrides?: CallOverrides): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + startMappingRecording(overrides?: CallOverrides): Promise; + + startStateDiffRecording(overrides?: CallOverrides): Promise; + + stopAndReturnStateDiff( + overrides?: CallOverrides + ): Promise; + + stopBroadcast(overrides?: CallOverrides): Promise; + + stopMappingRecording(overrides?: CallOverrides): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + unixTime(overrides?: CallOverrides): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + accesses( + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + addr( + privateKey: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbs(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqAbsDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRel(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(uint256,uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertApproxEqRelDecimal(int256,int256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + maxPercentDelta: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertFalse(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertGtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLe(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLeDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLt(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertLtDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool,bool)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bool[],bool[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address[],address[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string,string,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes,bytes,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256[],uint256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(address,address)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32,bytes32,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes32[],bytes32[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(string[],string[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256[],int256[],string)"( + left: PromiseOrValue[], + right: PromiseOrValue[], + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEq(bytes[],bytes[])"( + left: PromiseOrValue[], + right: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "assertNotEq(int256,int256)"( + left: PromiseOrValue, + right: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(int256,int256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertNotEqDecimal(uint256,uint256,uint256,string)"( + left: PromiseOrValue, + right: PromiseOrValue, + decimals: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool)"( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "assertTrue(bool,string)"( + condition: PromiseOrValue, + error: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + assume( + condition: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "breakpoint(string)"( + char: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "breakpoint(string,bool)"( + char: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "broadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + closeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "computeCreate2Address(bytes32,bytes32)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "computeCreate2Address(bytes32,bytes32,address)"( + salt: PromiseOrValue, + initCodeHash: PromiseOrValue, + deployer: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + computeCreateAddress( + deployer: PromiseOrValue, + nonce: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + copyFile( + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + createDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(string)"( + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "createWallet(uint256,string)"( + privateKey: PromiseOrValue, + walletLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "deriveKey(string,string,uint32,string)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32,string)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + language: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,uint32)"( + mnemonic: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deriveKey(string,string,uint32)"( + mnemonic: PromiseOrValue, + derivationPath: PromiseOrValue, + index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ensNamehash( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envAddress(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBool(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envBytes32(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + envExists( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envInt(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes32[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,int256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bool)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,address)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,uint256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bytes[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,uint256[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,string[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,bytes32)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,int256)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,address[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envOr(string,string)"( + name: PromiseOrValue, + defaultValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envOr(string,string,bool[])"( + name: PromiseOrValue, + delim: PromiseOrValue, + defaultValue: PromiseOrValue[], + overrides?: CallOverrides + ): Promise; + + "envString(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envString(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string)"( + name: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "envUint(string,string)"( + name: PromiseOrValue, + delim: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + eth_getLogs( + fromBlock: PromiseOrValue, + toBlock: PromiseOrValue, + target: PromiseOrValue, + topics: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + exists( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + ffi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + fsMetadata( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlobBaseFee(overrides?: CallOverrides): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getBlockTimestamp(overrides?: CallOverrides): Promise; + + getCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getDeployedCode( + artifactPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLabel( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getMappingKeyAndParentOf( + target: PromiseOrValue, + elementSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingLength( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getMappingSlotAt( + target: PromiseOrValue, + mappingSlot: PromiseOrValue, + idx: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "getNonce(address)"( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "getNonce((address,uint256,uint256,uint256))"( + wallet: VmSafe.WalletStruct, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + getRecordedLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + indexOf( + input: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isContext( + context: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isDir( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + keyExists( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsJson( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + keyExistsToml( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + label( + account: PromiseOrValue, + newLabel: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + lastCallGas(overrides?: CallOverrides): Promise; + + load( + target: PromiseOrValue, + slot: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseAddress( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBool( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseBytes32( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseInt( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string)"( + json: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseJson(string,string)"( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddress( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonAddressArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBool( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBoolArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytes32Array( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonBytesArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonInt( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonIntArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonKeys( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonString( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonStringArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUint( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseJsonUintArray( + json: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string,string)"( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "parseToml(string)"( + toml: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddress( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlAddressArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBool( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBoolArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytes32Array( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlBytesArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlInt( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlIntArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlKeys( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlString( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlStringArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUint( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseTomlUintArray( + toml: PromiseOrValue, + key: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + parseUint( + stringifiedValue: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + pauseGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + projectRoot(overrides?: CallOverrides): Promise; + + prompt( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptAddress( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecret( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptSecretUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + promptUint( + promptText: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + randomAddress( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "randomUint(uint256,uint256)"( + min: PromiseOrValue, + max: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "readDir(string,uint64)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string,uint64,bool)"( + path: PromiseOrValue, + maxDepth: PromiseOrValue, + followLinks: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "readDir(string)"( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFile( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readFileBinary( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLine( + path: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + readLink( + linkPath: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + record( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + recordLogs( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rememberKey( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeDir( + path: PromiseOrValue, + recursive: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + removeFile( + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + replace( + input: PromiseOrValue, + from: PromiseOrValue, + to: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + resumeGasMetering( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpc( + method: PromiseOrValue, + params: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + rpcUrl( + rpcAlias: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + rpcUrlStructs(overrides?: CallOverrides): Promise; + + rpcUrls(overrides?: CallOverrides): Promise; + + "serializeAddress(string,string,address[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeAddress(string,string,address)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBool(string,string,bool)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes(string,string,bytes)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeBytes32(string,string,bytes32)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeInt(string,string,int256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeJson( + objectKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeString(string,string,string)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256)"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "serializeUint(string,string,uint256[])"( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + values: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + serializeUintToHex( + objectKey: PromiseOrValue, + valueKey: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + setEnv( + name: PromiseOrValue, + value: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(bytes32)"( + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign(address,bytes32)"( + signer: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "sign((address,uint256,uint256,uint256),bytes32)"( + wallet: VmSafe.WalletStruct, + digest: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "sign(uint256,bytes32)"( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + signP256( + privateKey: PromiseOrValue, + digest: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + sleep( + duration: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + split( + input: PromiseOrValue, + delimiter: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "startBroadcast()"( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(address)"( + signer: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "startBroadcast(uint256)"( + privateKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + startStateDiffRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopAndReturnStateDiff( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopBroadcast( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + stopMappingRecording( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "toBase64(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(string)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toBase64URL(bytes)"( + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toLowercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(address)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(uint256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bool)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(int256)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "toString(bytes32)"( + value: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + toUppercase( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + trim( + input: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tryFfi( + commandInput: PromiseOrValue[], + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + unixTime( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFile( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeFileBinary( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeJson(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + writeLine( + path: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + valueKey: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "writeToml(string,string)"( + json: PromiseOrValue, + path: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/Vm.sol/index.ts b/typechain-types/forge-std/Vm.sol/index.ts new file mode 100644 index 00000000..6ea1a166 --- /dev/null +++ b/typechain-types/forge-std/Vm.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { Vm } from "./Vm"; +export type { VmSafe } from "./VmSafe"; diff --git a/typechain-types/forge-std/index.ts b/typechain-types/forge-std/index.ts new file mode 100644 index 00000000..8112c903 --- /dev/null +++ b/typechain-types/forge-std/index.ts @@ -0,0 +1,16 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as stdErrorSol from "./StdError.sol"; +export type { stdErrorSol }; +import type * as stdStorageSol from "./StdStorage.sol"; +export type { stdStorageSol }; +import type * as vmSol from "./Vm.sol"; +export type { vmSol }; +import type * as interfaces from "./interfaces"; +export type { interfaces }; +import type * as mocks from "./mocks"; +export type { mocks }; +export type { StdAssertions } from "./StdAssertions"; +export type { StdInvariant } from "./StdInvariant"; +export type { Test } from "./Test"; diff --git a/typechain-types/forge-std/interfaces/IERC165.ts b/typechain-types/forge-std/interfaces/IERC165.ts new file mode 100644 index 00000000..e1645ae5 --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC165.ts @@ -0,0 +1,103 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface IERC165Interface extends utils.Interface { + functions: { + "supportsInterface(bytes4)": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "supportsInterface"): FunctionFragment; + + encodeFunctionData( + functionFragment: "supportsInterface", + values: [PromiseOrValue] + ): string; + + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IERC165 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC165Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + }; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + callStatic: { + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + populateTransaction: { + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC20.ts b/typechain-types/forge-std/interfaces/IERC20.ts new file mode 100644 index 00000000..35a8ca5f --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC20.ts @@ -0,0 +1,384 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface IERC20Interface extends utils.Interface { + functions: { + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "decimals()": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "allowance" + | "approve" + | "balanceOf" + | "decimals" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface IERC20 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC20Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + }; + + estimateGas: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC721.sol/IERC721.ts b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721.ts new file mode 100644 index 00000000..1b01fec3 --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721.ts @@ -0,0 +1,560 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IERC721Interface extends utils.Interface { + functions: { + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "getApproved(uint256)": FunctionFragment; + "isApprovedForAll(address,address)": FunctionFragment; + "ownerOf(uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment; + "setApprovalForAll(address,bool)": FunctionFragment; + "supportsInterface(bytes4)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "approve" + | "balanceOf" + | "getApproved" + | "isApprovedForAll" + | "ownerOf" + | "safeTransferFrom(address,address,uint256)" + | "safeTransferFrom(address,address,uint256,bytes)" + | "setApprovalForAll" + | "supportsInterface" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getApproved", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isApprovedForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "ownerOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setApprovalForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "supportsInterface", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getApproved", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isApprovedForAll", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setApprovalForAll", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "ApprovalForAll(address,address,bool)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + _owner: string; + _approved: string; + _tokenId: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface ApprovalForAllEventObject { + _owner: string; + _operator: string; + _approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent< + [string, string, boolean], + ApprovalForAllEventObject +>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface TransferEventObject { + _from: string; + _to: string; + _tokenId: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface IERC721 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC721Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + Approval( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + + "ApprovalForAll(address,address,bool)"( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + ApprovalForAll( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + + "Transfer(address,address,uint256)"( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + Transfer( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + }; + + estimateGas: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Enumerable.ts b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Enumerable.ts new file mode 100644 index 00000000..9d2cc565 --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Enumerable.ts @@ -0,0 +1,655 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IERC721EnumerableInterface extends utils.Interface { + functions: { + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "getApproved(uint256)": FunctionFragment; + "isApprovedForAll(address,address)": FunctionFragment; + "ownerOf(uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment; + "setApprovalForAll(address,bool)": FunctionFragment; + "supportsInterface(bytes4)": FunctionFragment; + "tokenByIndex(uint256)": FunctionFragment; + "tokenOfOwnerByIndex(address,uint256)": FunctionFragment; + "totalSupply()": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "approve" + | "balanceOf" + | "getApproved" + | "isApprovedForAll" + | "ownerOf" + | "safeTransferFrom(address,address,uint256)" + | "safeTransferFrom(address,address,uint256,bytes)" + | "setApprovalForAll" + | "supportsInterface" + | "tokenByIndex" + | "tokenOfOwnerByIndex" + | "totalSupply" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getApproved", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isApprovedForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "ownerOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setApprovalForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "supportsInterface", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tokenByIndex", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "tokenOfOwnerByIndex", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getApproved", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isApprovedForAll", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setApprovalForAll", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "tokenByIndex", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "tokenOfOwnerByIndex", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "ApprovalForAll(address,address,bool)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + _owner: string; + _approved: string; + _tokenId: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface ApprovalForAllEventObject { + _owner: string; + _operator: string; + _approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent< + [string, string, boolean], + ApprovalForAllEventObject +>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface TransferEventObject { + _from: string; + _to: string; + _tokenId: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface IERC721Enumerable extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC721EnumerableInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + tokenByIndex( + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + tokenOfOwnerByIndex( + _owner: PromiseOrValue, + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenByIndex( + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenOfOwnerByIndex( + _owner: PromiseOrValue, + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenByIndex( + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenOfOwnerByIndex( + _owner: PromiseOrValue, + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + Approval( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + + "ApprovalForAll(address,address,bool)"( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + ApprovalForAll( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + + "Transfer(address,address,uint256)"( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + Transfer( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + }; + + estimateGas: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenByIndex( + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenOfOwnerByIndex( + _owner: PromiseOrValue, + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenByIndex( + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + tokenOfOwnerByIndex( + _owner: PromiseOrValue, + _index: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Metadata.ts b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Metadata.ts new file mode 100644 index 00000000..ffa90d03 --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721Metadata.ts @@ -0,0 +1,620 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IERC721MetadataInterface extends utils.Interface { + functions: { + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "getApproved(uint256)": FunctionFragment; + "isApprovedForAll(address,address)": FunctionFragment; + "name()": FunctionFragment; + "ownerOf(uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment; + "setApprovalForAll(address,bool)": FunctionFragment; + "supportsInterface(bytes4)": FunctionFragment; + "symbol()": FunctionFragment; + "tokenURI(uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "approve" + | "balanceOf" + | "getApproved" + | "isApprovedForAll" + | "name" + | "ownerOf" + | "safeTransferFrom(address,address,uint256)" + | "safeTransferFrom(address,address,uint256,bytes)" + | "setApprovalForAll" + | "supportsInterface" + | "symbol" + | "tokenURI" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getApproved", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isApprovedForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData( + functionFragment: "ownerOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setApprovalForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "supportsInterface", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenURI", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getApproved", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "isApprovedForAll", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setApprovalForAll", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "ApprovalForAll(address,address,bool)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + _owner: string; + _approved: string; + _tokenId: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface ApprovalForAllEventObject { + _owner: string; + _operator: string; + _approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent< + [string, string, boolean], + ApprovalForAllEventObject +>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface TransferEventObject { + _from: string; + _to: string; + _tokenId: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface IERC721Metadata extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC721MetadataInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + name(overrides?: CallOverrides): Promise<[string] & { _name: string }>; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + symbol(overrides?: CallOverrides): Promise<[string] & { _symbol: string }>; + + tokenURI( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + Approval( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + + "ApprovalForAll(address,address,bool)"( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + ApprovalForAll( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + + "Transfer(address,address,uint256)"( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + Transfer( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + }; + + estimateGas: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + approve( + _approved: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + _owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + _owner: PromiseOrValue, + _operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + _operator: PromiseOrValue, + _approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + _tokenId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + _from: PromiseOrValue, + _to: PromiseOrValue, + _tokenId: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver.ts b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver.ts new file mode 100644 index 00000000..98cfe54a --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver.ts @@ -0,0 +1,126 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IERC721TokenReceiverInterface extends utils.Interface { + functions: { + "onERC721Received(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction(nameOrSignatureOrTopic: "onERC721Received"): FunctionFragment; + + encodeFunctionData( + functionFragment: "onERC721Received", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "onERC721Received", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IERC721TokenReceiver extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IERC721TokenReceiverInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + onERC721Received( + _operator: PromiseOrValue, + _from: PromiseOrValue, + _tokenId: PromiseOrValue, + _data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + onERC721Received( + _operator: PromiseOrValue, + _from: PromiseOrValue, + _tokenId: PromiseOrValue, + _data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + onERC721Received( + _operator: PromiseOrValue, + _from: PromiseOrValue, + _tokenId: PromiseOrValue, + _data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + onERC721Received( + _operator: PromiseOrValue, + _from: PromiseOrValue, + _tokenId: PromiseOrValue, + _data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + onERC721Received( + _operator: PromiseOrValue, + _from: PromiseOrValue, + _tokenId: PromiseOrValue, + _data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/IERC721.sol/index.ts b/typechain-types/forge-std/interfaces/IERC721.sol/index.ts new file mode 100644 index 00000000..8df44aee --- /dev/null +++ b/typechain-types/forge-std/interfaces/IERC721.sol/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IERC721 } from "./IERC721"; +export type { IERC721Enumerable } from "./IERC721Enumerable"; +export type { IERC721Metadata } from "./IERC721Metadata"; +export type { IERC721TokenReceiver } from "./IERC721TokenReceiver"; diff --git a/typechain-types/forge-std/interfaces/IMulticall3.ts b/typechain-types/forge-std/interfaces/IMulticall3.ts new file mode 100644 index 00000000..a07e1cd4 --- /dev/null +++ b/typechain-types/forge-std/interfaces/IMulticall3.ts @@ -0,0 +1,598 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export declare namespace IMulticall3 { + export type CallStruct = { + target: PromiseOrValue; + callData: PromiseOrValue; + }; + + export type CallStructOutput = [string, string] & { + target: string; + callData: string; + }; + + export type Call3Struct = { + target: PromiseOrValue; + allowFailure: PromiseOrValue; + callData: PromiseOrValue; + }; + + export type Call3StructOutput = [string, boolean, string] & { + target: string; + allowFailure: boolean; + callData: string; + }; + + export type ResultStruct = { + success: PromiseOrValue; + returnData: PromiseOrValue; + }; + + export type ResultStructOutput = [boolean, string] & { + success: boolean; + returnData: string; + }; + + export type Call3ValueStruct = { + target: PromiseOrValue; + allowFailure: PromiseOrValue; + value: PromiseOrValue; + callData: PromiseOrValue; + }; + + export type Call3ValueStructOutput = [string, boolean, BigNumber, string] & { + target: string; + allowFailure: boolean; + value: BigNumber; + callData: string; + }; +} + +export interface IMulticall3Interface extends utils.Interface { + functions: { + "aggregate((address,bytes)[])": FunctionFragment; + "aggregate3((address,bool,bytes)[])": FunctionFragment; + "aggregate3Value((address,bool,uint256,bytes)[])": FunctionFragment; + "blockAndAggregate((address,bytes)[])": FunctionFragment; + "getBasefee()": FunctionFragment; + "getBlockHash(uint256)": FunctionFragment; + "getBlockNumber()": FunctionFragment; + "getChainId()": FunctionFragment; + "getCurrentBlockCoinbase()": FunctionFragment; + "getCurrentBlockDifficulty()": FunctionFragment; + "getCurrentBlockGasLimit()": FunctionFragment; + "getCurrentBlockTimestamp()": FunctionFragment; + "getEthBalance(address)": FunctionFragment; + "getLastBlockHash()": FunctionFragment; + "tryAggregate(bool,(address,bytes)[])": FunctionFragment; + "tryBlockAndAggregate(bool,(address,bytes)[])": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "aggregate" + | "aggregate3" + | "aggregate3Value" + | "blockAndAggregate" + | "getBasefee" + | "getBlockHash" + | "getBlockNumber" + | "getChainId" + | "getCurrentBlockCoinbase" + | "getCurrentBlockDifficulty" + | "getCurrentBlockGasLimit" + | "getCurrentBlockTimestamp" + | "getEthBalance" + | "getLastBlockHash" + | "tryAggregate" + | "tryBlockAndAggregate" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "aggregate", + values: [IMulticall3.CallStruct[]] + ): string; + encodeFunctionData( + functionFragment: "aggregate3", + values: [IMulticall3.Call3Struct[]] + ): string; + encodeFunctionData( + functionFragment: "aggregate3Value", + values: [IMulticall3.Call3ValueStruct[]] + ): string; + encodeFunctionData( + functionFragment: "blockAndAggregate", + values: [IMulticall3.CallStruct[]] + ): string; + encodeFunctionData( + functionFragment: "getBasefee", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getBlockHash", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getBlockNumber", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getChainId", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCurrentBlockCoinbase", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCurrentBlockDifficulty", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCurrentBlockGasLimit", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getCurrentBlockTimestamp", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "getEthBalance", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getLastBlockHash", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "tryAggregate", + values: [PromiseOrValue, IMulticall3.CallStruct[]] + ): string; + encodeFunctionData( + functionFragment: "tryBlockAndAggregate", + values: [PromiseOrValue, IMulticall3.CallStruct[]] + ): string; + + decodeFunctionResult(functionFragment: "aggregate", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "aggregate3", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "aggregate3Value", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "blockAndAggregate", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getBasefee", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getBlockHash", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getBlockNumber", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "getChainId", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getCurrentBlockCoinbase", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getCurrentBlockDifficulty", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getCurrentBlockGasLimit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getCurrentBlockTimestamp", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getEthBalance", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "getLastBlockHash", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "tryAggregate", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "tryBlockAndAggregate", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IMulticall3 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IMulticall3Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + aggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3( + calls: IMulticall3.Call3Struct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3Value( + calls: IMulticall3.Call3ValueStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + blockAndAggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + getBasefee( + overrides?: CallOverrides + ): Promise<[BigNumber] & { basefee: BigNumber }>; + + getBlockHash( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { blockHash: string }>; + + getBlockNumber( + overrides?: CallOverrides + ): Promise<[BigNumber] & { blockNumber: BigNumber }>; + + getChainId( + overrides?: CallOverrides + ): Promise<[BigNumber] & { chainid: BigNumber }>; + + getCurrentBlockCoinbase( + overrides?: CallOverrides + ): Promise<[string] & { coinbase: string }>; + + getCurrentBlockDifficulty( + overrides?: CallOverrides + ): Promise<[BigNumber] & { difficulty: BigNumber }>; + + getCurrentBlockGasLimit( + overrides?: CallOverrides + ): Promise<[BigNumber] & { gaslimit: BigNumber }>; + + getCurrentBlockTimestamp( + overrides?: CallOverrides + ): Promise<[BigNumber] & { timestamp: BigNumber }>; + + getEthBalance( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber] & { balance: BigNumber }>; + + getLastBlockHash( + overrides?: CallOverrides + ): Promise<[string] & { blockHash: string }>; + + tryAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + tryBlockAndAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + aggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3( + calls: IMulticall3.Call3Struct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3Value( + calls: IMulticall3.Call3ValueStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + blockAndAggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + getBasefee(overrides?: CallOverrides): Promise; + + getBlockHash( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getChainId(overrides?: CallOverrides): Promise; + + getCurrentBlockCoinbase(overrides?: CallOverrides): Promise; + + getCurrentBlockDifficulty(overrides?: CallOverrides): Promise; + + getCurrentBlockGasLimit(overrides?: CallOverrides): Promise; + + getCurrentBlockTimestamp(overrides?: CallOverrides): Promise; + + getEthBalance( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLastBlockHash(overrides?: CallOverrides): Promise; + + tryAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + tryBlockAndAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + aggregate( + calls: IMulticall3.CallStruct[], + overrides?: CallOverrides + ): Promise< + [BigNumber, string[]] & { blockNumber: BigNumber; returnData: string[] } + >; + + aggregate3( + calls: IMulticall3.Call3Struct[], + overrides?: CallOverrides + ): Promise; + + aggregate3Value( + calls: IMulticall3.Call3ValueStruct[], + overrides?: CallOverrides + ): Promise; + + blockAndAggregate( + calls: IMulticall3.CallStruct[], + overrides?: CallOverrides + ): Promise< + [BigNumber, string, IMulticall3.ResultStructOutput[]] & { + blockNumber: BigNumber; + blockHash: string; + returnData: IMulticall3.ResultStructOutput[]; + } + >; + + getBasefee(overrides?: CallOverrides): Promise; + + getBlockHash( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getChainId(overrides?: CallOverrides): Promise; + + getCurrentBlockCoinbase(overrides?: CallOverrides): Promise; + + getCurrentBlockDifficulty(overrides?: CallOverrides): Promise; + + getCurrentBlockGasLimit(overrides?: CallOverrides): Promise; + + getCurrentBlockTimestamp(overrides?: CallOverrides): Promise; + + getEthBalance( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLastBlockHash(overrides?: CallOverrides): Promise; + + tryAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: CallOverrides + ): Promise; + + tryBlockAndAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: CallOverrides + ): Promise< + [BigNumber, string, IMulticall3.ResultStructOutput[]] & { + blockNumber: BigNumber; + blockHash: string; + returnData: IMulticall3.ResultStructOutput[]; + } + >; + }; + + filters: {}; + + estimateGas: { + aggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3( + calls: IMulticall3.Call3Struct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3Value( + calls: IMulticall3.Call3ValueStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + blockAndAggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + getBasefee(overrides?: CallOverrides): Promise; + + getBlockHash( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getChainId(overrides?: CallOverrides): Promise; + + getCurrentBlockCoinbase(overrides?: CallOverrides): Promise; + + getCurrentBlockDifficulty(overrides?: CallOverrides): Promise; + + getCurrentBlockGasLimit(overrides?: CallOverrides): Promise; + + getCurrentBlockTimestamp(overrides?: CallOverrides): Promise; + + getEthBalance( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLastBlockHash(overrides?: CallOverrides): Promise; + + tryAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + tryBlockAndAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + aggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3( + calls: IMulticall3.Call3Struct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + aggregate3Value( + calls: IMulticall3.Call3ValueStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + blockAndAggregate( + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + getBasefee(overrides?: CallOverrides): Promise; + + getBlockHash( + blockNumber: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getBlockNumber(overrides?: CallOverrides): Promise; + + getChainId(overrides?: CallOverrides): Promise; + + getCurrentBlockCoinbase( + overrides?: CallOverrides + ): Promise; + + getCurrentBlockDifficulty( + overrides?: CallOverrides + ): Promise; + + getCurrentBlockGasLimit( + overrides?: CallOverrides + ): Promise; + + getCurrentBlockTimestamp( + overrides?: CallOverrides + ): Promise; + + getEthBalance( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getLastBlockHash(overrides?: CallOverrides): Promise; + + tryAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + tryBlockAndAggregate( + requireSuccess: PromiseOrValue, + calls: IMulticall3.CallStruct[], + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/interfaces/index.ts b/typechain-types/forge-std/interfaces/index.ts new file mode 100644 index 00000000..0e278083 --- /dev/null +++ b/typechain-types/forge-std/interfaces/index.ts @@ -0,0 +1,8 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as ierc721Sol from "./IERC721.sol"; +export type { ierc721Sol }; +export type { IERC165 } from "./IERC165"; +export type { IERC20 } from "./IERC20"; +export type { IMulticall3 } from "./IMulticall3"; diff --git a/typechain-types/forge-std/mocks/MockERC20.ts b/typechain-types/forge-std/mocks/MockERC20.ts new file mode 100644 index 00000000..ba397218 --- /dev/null +++ b/typechain-types/forge-std/mocks/MockERC20.ts @@ -0,0 +1,552 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface MockERC20Interface extends utils.Interface { + functions: { + "DOMAIN_SEPARATOR()": FunctionFragment; + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "decimals()": FunctionFragment; + "initialize(string,string,uint8)": FunctionFragment; + "name()": FunctionFragment; + "nonces(address)": FunctionFragment; + "permit(address,address,uint256,uint256,uint8,bytes32,bytes32)": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "DOMAIN_SEPARATOR" + | "allowance" + | "approve" + | "balanceOf" + | "decimals" + | "initialize" + | "name" + | "nonces" + | "permit" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "DOMAIN_SEPARATOR", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "initialize", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData( + functionFragment: "nonces", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "permit", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult( + functionFragment: "DOMAIN_SEPARATOR", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "nonces", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "permit", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface MockERC20 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: MockERC20Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + nonces( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + permit( + owner: PromiseOrValue, + spender: PromiseOrValue, + value: PromiseOrValue, + deadline: PromiseOrValue, + v: PromiseOrValue, + r: PromiseOrValue, + s: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + nonces( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + permit( + owner: PromiseOrValue, + spender: PromiseOrValue, + value: PromiseOrValue, + deadline: PromiseOrValue, + v: PromiseOrValue, + r: PromiseOrValue, + s: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + nonces( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + permit( + owner: PromiseOrValue, + spender: PromiseOrValue, + value: PromiseOrValue, + deadline: PromiseOrValue, + v: PromiseOrValue, + r: PromiseOrValue, + s: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + }; + + estimateGas: { + DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + nonces( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + permit( + owner: PromiseOrValue, + spender: PromiseOrValue, + value: PromiseOrValue, + deadline: PromiseOrValue, + v: PromiseOrValue, + r: PromiseOrValue, + s: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + nonces( + arg0: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + permit( + owner: PromiseOrValue, + spender: PromiseOrValue, + value: PromiseOrValue, + deadline: PromiseOrValue, + v: PromiseOrValue, + r: PromiseOrValue, + s: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/mocks/MockERC721.ts b/typechain-types/forge-std/mocks/MockERC721.ts new file mode 100644 index 00000000..2f516783 --- /dev/null +++ b/typechain-types/forge-std/mocks/MockERC721.ts @@ -0,0 +1,657 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../common"; + +export interface MockERC721Interface extends utils.Interface { + functions: { + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "getApproved(uint256)": FunctionFragment; + "initialize(string,string)": FunctionFragment; + "isApprovedForAll(address,address)": FunctionFragment; + "name()": FunctionFragment; + "ownerOf(uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256)": FunctionFragment; + "safeTransferFrom(address,address,uint256,bytes)": FunctionFragment; + "setApprovalForAll(address,bool)": FunctionFragment; + "supportsInterface(bytes4)": FunctionFragment; + "symbol()": FunctionFragment; + "tokenURI(uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "approve" + | "balanceOf" + | "getApproved" + | "initialize" + | "isApprovedForAll" + | "name" + | "ownerOf" + | "safeTransferFrom(address,address,uint256)" + | "safeTransferFrom(address,address,uint256,bytes)" + | "setApprovalForAll" + | "supportsInterface" + | "symbol" + | "tokenURI" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "getApproved", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "initialize", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "isApprovedForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData( + functionFragment: "ownerOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "setApprovalForAll", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "supportsInterface", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "tokenURI", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "getApproved", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "isApprovedForAll", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "ownerOf", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "safeTransferFrom(address,address,uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "setApprovalForAll", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "supportsInterface", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "tokenURI", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "ApprovalForAll(address,address,bool)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + _owner: string; + _approved: string; + _tokenId: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface ApprovalForAllEventObject { + _owner: string; + _operator: string; + _approved: boolean; +} +export type ApprovalForAllEvent = TypedEvent< + [string, string, boolean], + ApprovalForAllEventObject +>; + +export type ApprovalForAllEventFilter = TypedEventFilter; + +export interface TransferEventObject { + _from: string; + _to: string; + _tokenId: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface MockERC721 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: MockERC721Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + approve( + spender: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + getApproved( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isApprovedForAll( + owner: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + name(overrides?: CallOverrides): Promise<[string]>; + + ownerOf( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string] & { owner: string }>; + + "safeTransferFrom(address,address,uint256)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceId: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[boolean]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + tokenURI( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + approve( + spender: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isApprovedForAll( + owner: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + approve( + spender: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + isApprovedForAll( + owner: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + supportsInterface( + interfaceId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + Approval( + _owner?: PromiseOrValue | null, + _approved?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): ApprovalEventFilter; + + "ApprovalForAll(address,address,bool)"( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + ApprovalForAll( + _owner?: PromiseOrValue | null, + _operator?: PromiseOrValue | null, + _approved?: null + ): ApprovalForAllEventFilter; + + "Transfer(address,address,uint256)"( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + Transfer( + _from?: PromiseOrValue | null, + _to?: PromiseOrValue | null, + _tokenId?: PromiseOrValue | null + ): TransferEventFilter; + }; + + estimateGas: { + approve( + spender: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isApprovedForAll( + owner: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + approve( + spender: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + owner: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + getApproved( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + initialize( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + isApprovedForAll( + owner: PromiseOrValue, + operator: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + ownerOf( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "safeTransferFrom(address,address,uint256)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "safeTransferFrom(address,address,uint256,bytes)"( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + setApprovalForAll( + operator: PromiseOrValue, + approved: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + supportsInterface( + interfaceId: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + symbol(overrides?: CallOverrides): Promise; + + tokenURI( + id: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + id: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/forge-std/mocks/index.ts b/typechain-types/forge-std/mocks/index.ts new file mode 100644 index 00000000..bb1eac6a --- /dev/null +++ b/typechain-types/forge-std/mocks/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { MockERC20 } from "./MockERC20"; +export type { MockERC721 } from "./MockERC721"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 6f78440d..60f76a34 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -340,6 +340,10 @@ declare module "hardhat/types/runtime" { name: "GatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayEVMTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayEVMUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions @@ -348,6 +352,18 @@ declare module "hardhat/types/runtime" { name: "IGatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IGatewayEVMErrors", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IGatewayEVMEvents", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IReceiverEVMEvents", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ReceiverEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -448,6 +464,70 @@ declare module "hardhat/types/runtime" { name: "ZRC20Errors", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IERC165", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC20", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC721", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC721Enumerable", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC721Metadata", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IERC721TokenReceiver", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "IMulticall3", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "MockERC20", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "MockERC721", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "StdAssertions", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "StdError", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "StdInvariant", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "StdStorageSafe", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "Test", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "Vm", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "VmSafe", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractAt( name: "OwnableUpgradeable", @@ -859,6 +939,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayEVMTest", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayEVMUpgradeTest", address: string, @@ -869,6 +954,21 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IGatewayEVMErrors", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IGatewayEVMEvents", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IReceiverEVMEvents", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ReceiverEVM", address: string, @@ -994,6 +1094,86 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IERC165", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC20", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC721", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC721Enumerable", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC721Metadata", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IERC721TokenReceiver", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "IMulticall3", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "MockERC20", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "MockERC721", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "StdAssertions", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "StdError", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "StdInvariant", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "StdStorageSafe", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "Test", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "Vm", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "VmSafe", + address: string, + signer?: ethers.Signer + ): Promise; // default types getContractFactory( diff --git a/typechain-types/index.ts b/typechain-types/index.ts index f17533ca..208fd59c 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -7,6 +7,8 @@ import type * as uniswap from "./@uniswap"; export type { uniswap }; import type * as contracts from "./contracts"; export type { contracts }; +import type * as forgeStd from "./forge-std"; +export type { forgeStd }; export * as factories from "./factories"; export type { OwnableUpgradeable } from "./@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable"; export { OwnableUpgradeable__factory } from "./factories/@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable__factory"; @@ -160,10 +162,18 @@ export type { ERC20CustodyNew } from "./contracts/prototypes/evm/ERC20CustodyNew export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNew__factory"; export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; +export type { GatewayEVMTest } from "./contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest"; +export { GatewayEVMTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory"; export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory"; +export type { IGatewayEVMErrors } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors"; +export { IGatewayEVMErrors__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory"; +export type { IGatewayEVMEvents } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents"; +export { IGatewayEVMEvents__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory"; +export type { IReceiverEVMEvents } from "./contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents"; +export { IReceiverEVMEvents__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory"; export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; @@ -200,3 +210,33 @@ export type { ZetaConnectorZEVM } from "./contracts/zevm/ZetaConnectorZEVM.sol/Z export { ZetaConnectorZEVM__factory } from "./factories/contracts/zevm/ZetaConnectorZEVM.sol/ZetaConnectorZEVM__factory"; export type { ZRC20 } from "./contracts/zevm/ZRC20.sol/ZRC20"; export { ZRC20__factory } from "./factories/contracts/zevm/ZRC20.sol/ZRC20__factory"; +export type { IERC165 } from "./forge-std/interfaces/IERC165"; +export { IERC165__factory } from "./factories/forge-std/interfaces/IERC165__factory"; +export type { IERC721 } from "./forge-std/interfaces/IERC721.sol/IERC721"; +export { IERC721__factory } from "./factories/forge-std/interfaces/IERC721.sol/IERC721__factory"; +export type { IERC721Enumerable } from "./forge-std/interfaces/IERC721.sol/IERC721Enumerable"; +export { IERC721Enumerable__factory } from "./factories/forge-std/interfaces/IERC721.sol/IERC721Enumerable__factory"; +export type { IERC721Metadata } from "./forge-std/interfaces/IERC721.sol/IERC721Metadata"; +export { IERC721Metadata__factory } from "./factories/forge-std/interfaces/IERC721.sol/IERC721Metadata__factory"; +export type { IERC721TokenReceiver } from "./forge-std/interfaces/IERC721.sol/IERC721TokenReceiver"; +export { IERC721TokenReceiver__factory } from "./factories/forge-std/interfaces/IERC721.sol/IERC721TokenReceiver__factory"; +export type { IMulticall3 } from "./forge-std/interfaces/IMulticall3"; +export { IMulticall3__factory } from "./factories/forge-std/interfaces/IMulticall3__factory"; +export type { MockERC20 } from "./forge-std/mocks/MockERC20"; +export { MockERC20__factory } from "./factories/forge-std/mocks/MockERC20__factory"; +export type { MockERC721 } from "./forge-std/mocks/MockERC721"; +export { MockERC721__factory } from "./factories/forge-std/mocks/MockERC721__factory"; +export type { StdAssertions } from "./forge-std/StdAssertions"; +export { StdAssertions__factory } from "./factories/forge-std/StdAssertions__factory"; +export type { StdError } from "./forge-std/StdError.sol/StdError"; +export { StdError__factory } from "./factories/forge-std/StdError.sol/StdError__factory"; +export type { StdInvariant } from "./forge-std/StdInvariant"; +export { StdInvariant__factory } from "./factories/forge-std/StdInvariant__factory"; +export type { StdStorageSafe } from "./forge-std/StdStorage.sol/StdStorageSafe"; +export { StdStorageSafe__factory } from "./factories/forge-std/StdStorage.sol/StdStorageSafe__factory"; +export type { Test } from "./forge-std/Test"; +export { Test__factory } from "./factories/forge-std/Test__factory"; +export type { Vm } from "./forge-std/Vm.sol/Vm"; +export { Vm__factory } from "./factories/forge-std/Vm.sol/Vm__factory"; +export type { VmSafe } from "./forge-std/Vm.sol/VmSafe"; +export { VmSafe__factory } from "./factories/forge-std/Vm.sol/VmSafe__factory"; From e881d7c3a60c689d3f0b0c3c490705f97e536a56 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 8 Jul 2024 20:46:40 +0200 Subject: [PATCH 60/86] more foundry tests --- .../prototypes/{evm => test}/GatewayEVM.t.sol | 2 +- .../prototypes/test/GatewayIntegration.t.sol | 103 ++++++++++++++++++ contracts/prototypes/zevm/GatewayZEVM.sol | 6 +- contracts/prototypes/zevm/interfaces.sol | 5 + contracts/zevm/Interfaces.sol | 62 ----------- contracts/zevm/ZRC20.sol | 8 +- contracts/{prototypes => }/zevm/ZRC20New.sol | 8 +- contracts/zevm/interfaces/ISystem.sol | 19 ++++ contracts/zevm/interfaces/IZRC20.sol | 38 ++++++- 9 files changed, 172 insertions(+), 79 deletions(-) rename contracts/prototypes/{evm => test}/GatewayEVM.t.sol (98%) create mode 100644 contracts/prototypes/test/GatewayIntegration.t.sol delete mode 100644 contracts/zevm/Interfaces.sol rename contracts/{prototypes => }/zevm/ZRC20New.sol (97%) create mode 100644 contracts/zevm/interfaces/ISystem.sol diff --git a/contracts/prototypes/evm/GatewayEVM.t.sol b/contracts/prototypes/test/GatewayEVM.t.sol similarity index 98% rename from contracts/prototypes/evm/GatewayEVM.t.sol rename to contracts/prototypes/test/GatewayEVM.t.sol index dea62917..6d5430de 100644 --- a/contracts/prototypes/evm/GatewayEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVM.t.sol @@ -10,7 +10,7 @@ import "contracts/prototypes/evm/ERC20CustodyNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "./interfaces.sol"; +import "../evm/interfaces.sol"; import "forge-std/console.sol"; contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiverEVMEvents { diff --git a/contracts/prototypes/test/GatewayIntegration.t.sol b/contracts/prototypes/test/GatewayIntegration.t.sol new file mode 100644 index 00000000..a69278f8 --- /dev/null +++ b/contracts/prototypes/test/GatewayIntegration.t.sol @@ -0,0 +1,103 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "forge-std/Test.sol"; +import "forge-std/Vm.sol"; + +import "contracts/prototypes/evm/GatewayEVM.sol"; +import "contracts/prototypes/evm/ReceiverEVM.sol"; +import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/TestERC20.sol"; +import "contracts/prototypes/evm/ReceiverEVM.sol"; + +import "contracts/prototypes/zevm/GatewayZEVM.sol"; +import "contracts/prototypes/zevm/SenderZEVM.sol"; +import "contracts/zevm/ZRC20New.sol"; +import "contracts/zevm/testing/SystemContractMock.sol"; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "../evm/interfaces.sol"; +import "../zevm/interfaces.sol"; +import "forge-std/console.sol"; + +contract GatewayIntegrationTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGatewayZEVMEvents, IReceiverEVMEvents { + // evm + using SafeERC20 for IERC20; + + GatewayEVM gatewayEVM; + ERC20CustodyNew custody; + TestERC20 token; + ReceiverEVM receiverEVM; + address ownerEVM; + address destination; + address tssAddress; + + // zevm + GatewayZEVM gatewayZEVM; + SenderZEVM senderZEVM; + SystemContractMock systemContract; + ZRC20New zrc20; + address ownerZEVM; + + function setUp() public { + // evm + ownerEVM = address(this); + destination = address(0x1234); + tssAddress = address(0x5678); + ownerZEVM = address(0x4321); + + token = new TestERC20("test", "TTK"); + gatewayEVM = new GatewayEVM(); + custody = new ERC20CustodyNew(address(gatewayEVM)); + + gatewayEVM.initialize(tssAddress); + gatewayEVM.setCustody(address(custody)); + + // Mint initial supply to the ownerEVM + token.mint(ownerEVM, 1000000); + + // Transfer some tokens to the custody contract + token.transfer(address(custody), 500000); + + receiverEVM = new ReceiverEVM(); + + // zevm + // Impersonate the fungible module account + gatewayZEVM = new GatewayZEVM(); + + senderZEVM = new SenderZEVM(address(gatewayZEVM)); + address fungibleModuleAddress = address(0x735b14BB79463307AAcBED86DAf3322B1e6226aB); + vm.startPrank(fungibleModuleAddress); + systemContract = new SystemContractMock(address(0), address(0), address(0)); + zrc20 = new ZRC20New("TOKEN", "TKN", 18, 1, CoinType.Zeta, 0, address(systemContract), address(gatewayZEVM)); + systemContract.setGasCoinZRC20(1, address(zrc20)); + systemContract.setGasPrice(1, 1); + zrc20.deposit(ownerZEVM, 1000000); + zrc20.deposit(address(senderZEVM), 1000000); + vm.stopPrank(); + + vm.prank(ownerZEVM); + zrc20.approve(address(gatewayZEVM), 1000000); + } + + function testCallReceiverEVMFromZEVM() public { + string memory str = "Hello, Hardhat!"; + uint256 num = 42; + bool flag = true; + uint256 value = 1 ether; + + // Encode the function call data and call on zevm + bytes memory message = abi.encodeWithSelector(receiverEVM.receivePayable.selector, str, num, flag); + vm.prank(ownerZEVM); + vm.expectEmit(true, true, true, true, address(gatewayZEVM)); + emit Call(address(ownerZEVM), abi.encodePacked(receiverEVM), message); + gatewayZEVM.call(abi.encodePacked(receiverEVM), message); + + // Call execute on evm + vm.deal(address(gatewayEVM), value); + vm.expectEmit(true, true, true, true, address(gatewayEVM)); + emit Executed(address(receiverEVM), value, message); + gatewayEVM.execute{value: value}(address(receiverEVM), message); + } +} \ No newline at end of file diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index bb0c3eb3..0730a864 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -6,10 +6,11 @@ import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "../../zevm/interfaces/IZRC20.sol"; import "../../zevm/interfaces/zContract.sol"; +import "./interfaces.sol"; // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances -contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayZEVM is IGatewayZEVMEvents, Initializable, OwnableUpgradeable, UUPSUpgradeable { address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; error WithdrawalFailed(); @@ -20,9 +21,6 @@ contract GatewayZEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable { error CallerIsNotFungibleModule(); error InvalidTarget(); - event Call(address indexed sender, bytes receiver, bytes message); - event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); - /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/interfaces.sol index 0ac42801..60088a5c 100644 --- a/contracts/prototypes/zevm/interfaces.sol +++ b/contracts/prototypes/zevm/interfaces.sol @@ -31,4 +31,9 @@ interface IGatewayZEVM { address target, bytes calldata message ) external; +} + +interface IGatewayZEVMEvents { + event Call(address indexed sender, bytes receiver, bytes message); + event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); } \ No newline at end of file diff --git a/contracts/zevm/Interfaces.sol b/contracts/zevm/Interfaces.sol deleted file mode 100644 index f9bba9b2..00000000 --- a/contracts/zevm/Interfaces.sol +++ /dev/null @@ -1,62 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.7; - -/** - * @dev Interfaces of SystemContract and ZRC20 to make easier to import. - */ -interface ISystem { - function FUNGIBLE_MODULE_ADDRESS() external view returns (address); - - function wZetaContractAddress() external view returns (address); - - function uniswapv2FactoryAddress() external view returns (address); - - function gasPriceByChainId(uint256 chainID) external view returns (uint256); - - function gasCoinZRC20ByChainId(uint256 chainID) external view returns (address); - - function gasZetaPoolByChainId(uint256 chainID) external view returns (address); -} - -interface IZRC20 { - function totalSupply() external view returns (uint256); - - function balanceOf(address account) external view returns (uint256); - - function transfer(address recipient, uint256 amount) external returns (bool); - - function allowance(address owner, address spender) external view returns (uint256); - - function approve(address spender, uint256 amount) external returns (bool); - - function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); - - function deposit(address to, uint256 amount) external returns (bool); - - function withdraw(bytes memory to, uint256 amount) external returns (bool); - - function withdrawGasFee() external view returns (address, uint256); - - event Transfer(address indexed from, address indexed to, uint256 value); - event Approval(address indexed owner, address indexed spender, uint256 value); - event Deposit(bytes from, address indexed to, uint256 value); - event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee); - event UpdatedSystemContract(address systemContract); - event UpdatedGasLimit(uint256 gasLimit); - event UpdatedProtocolFlatFee(uint256 protocolFlatFee); -} - -interface IZRC20Metadata is IZRC20 { - function name() external view returns (string memory); - - function symbol() external view returns (string memory); - - function decimals() external view returns (uint8); -} - -/// @dev Coin types for ZRC20. Zeta value should not be used. -enum CoinType { - Zeta, - Gas, - ERC20 -} diff --git a/contracts/zevm/ZRC20.sol b/contracts/zevm/ZRC20.sol index 5d758c89..21a6e5f5 100644 --- a/contracts/zevm/ZRC20.sol +++ b/contracts/zevm/ZRC20.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; -import "./Interfaces.sol"; +import "./interfaces/IZRC20.sol"; /** * @dev Custom errors for ZRC20 @@ -17,7 +17,7 @@ interface ZRC20Errors { error ZeroAddress(); } -contract ZRC20 is IZRC20, IZRC20Metadata, ZRC20Errors { +contract ZRC20 is IZRC20Metadata, ZRC20Events, ZRC20Errors { /// @notice Fungible address is always the same, maintained at the protocol level address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; /// @notice Chain id.abi @@ -29,7 +29,7 @@ contract ZRC20 is IZRC20, IZRC20Metadata, ZRC20Errors { /// @notice Gas limit. uint256 public GAS_LIMIT; /// @notice Protocol flat fee. - uint256 public PROTOCOL_FLAT_FEE; + uint256 public override PROTOCOL_FLAT_FEE; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; @@ -170,7 +170,7 @@ contract ZRC20 is IZRC20, IZRC20Metadata, ZRC20Errors { * @param amount, amount to burn. * @return true/false if succeeded/failed. */ - function burn(uint256 amount) external returns (bool) { + function burn(uint256 amount) external override returns (bool) { _burn(msg.sender, amount); return true; } diff --git a/contracts/prototypes/zevm/ZRC20New.sol b/contracts/zevm/ZRC20New.sol similarity index 97% rename from contracts/prototypes/zevm/ZRC20New.sol rename to contracts/zevm/ZRC20New.sol index 62f55ce5..adc8fbde 100644 --- a/contracts/prototypes/zevm/ZRC20New.sol +++ b/contracts/zevm/ZRC20New.sol @@ -1,6 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; -import "../../zevm/Interfaces.sol"; +import "./interfaces/IZRC20.sol"; /** * @dev Custom errors for ZRC20 @@ -19,7 +19,7 @@ interface ZRC20Errors { // NOTE: this is exactly the same as ZRC20, except gateway contract address is set at deployment // and used to allow deposit. This is first version, it might change in the future. -contract ZRC20New is IZRC20, IZRC20Metadata, ZRC20Errors { +contract ZRC20New is IZRC20Metadata, ZRC20Errors, ZRC20Events { /// @notice Fungible address is always the same, maintained at the protocol level address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; /// @notice Chain id.abi @@ -33,7 +33,7 @@ contract ZRC20New is IZRC20, IZRC20Metadata, ZRC20Errors { /// @notice Gas limit. uint256 public GAS_LIMIT; /// @notice Protocol flat fee. - uint256 public PROTOCOL_FLAT_FEE; + uint256 public override PROTOCOL_FLAT_FEE; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; @@ -176,7 +176,7 @@ contract ZRC20New is IZRC20, IZRC20Metadata, ZRC20Errors { * @param amount, amount to burn. * @return true/false if succeeded/failed. */ - function burn(uint256 amount) external returns (bool) { + function burn(uint256 amount) external override returns (bool) { _burn(msg.sender, amount); return true; } diff --git a/contracts/zevm/interfaces/ISystem.sol b/contracts/zevm/interfaces/ISystem.sol new file mode 100644 index 00000000..f8fb70bd --- /dev/null +++ b/contracts/zevm/interfaces/ISystem.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +/** + * @dev Interfaces of SystemContract and ZRC20 to make easier to import. + */ +interface ISystem { + function FUNGIBLE_MODULE_ADDRESS() external view returns (address); + + function wZetaContractAddress() external view returns (address); + + function uniswapv2FactoryAddress() external view returns (address); + + function gasPriceByChainId(uint256 chainID) external view returns (uint256); + + function gasCoinZRC20ByChainId(uint256 chainID) external view returns (address); + + function gasZetaPoolByChainId(uint256 chainID) external view returns (address); +} diff --git a/contracts/zevm/interfaces/IZRC20.sol b/contracts/zevm/interfaces/IZRC20.sol index eab06e7f..6b811cf5 100644 --- a/contracts/zevm/interfaces/IZRC20.sol +++ b/contracts/zevm/interfaces/IZRC20.sol @@ -1,6 +1,23 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; +/** + * @dev Interfaces of SystemContract and ZRC20 to make easier to import. + */ +interface ISystem { + function FUNGIBLE_MODULE_ADDRESS() external view returns (address); + + function wZetaContractAddress() external view returns (address); + + function uniswapv2FactoryAddress() external view returns (address); + + function gasPriceByChainId(uint256 chainID) external view returns (uint256); + + function gasCoinZRC20ByChainId(uint256 chainID) external view returns (address); + + function gasZetaPoolByChainId(uint256 chainID) external view returns (address); +} + interface IZRC20 { function totalSupply() external view returns (uint256); @@ -12,10 +29,6 @@ interface IZRC20 { function approve(address spender, uint256 amount) external returns (bool); - function decreaseAllowance(address spender, uint256 amount) external returns (bool); - - function increaseAllowance(address spender, uint256 amount) external returns (bool); - function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function deposit(address to, uint256 amount) external returns (bool); @@ -27,7 +40,17 @@ interface IZRC20 { function withdrawGasFee() external view returns (address, uint256); function PROTOCOL_FLAT_FEE() external view returns (uint256); +} + +interface IZRC20Metadata is IZRC20 { + function name() external view returns (string memory); + + function symbol() external view returns (string memory); + function decimals() external view returns (uint8); +} + +interface ZRC20Events { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Deposit(bytes from, address indexed to, uint256 value); @@ -36,3 +59,10 @@ interface IZRC20 { event UpdatedGasLimit(uint256 gasLimit); event UpdatedProtocolFlatFee(uint256 protocolFlatFee); } + +/// @dev Coin types for ZRC20. Zeta value should not be used. +enum CoinType { + Zeta, + Gas, + ERC20 +} From c4f89f816adb79a4f25ea583905a22da4ea18917 Mon Sep 17 00:00:00 2001 From: skosito Date: Mon, 8 Jul 2024 20:51:53 +0200 Subject: [PATCH 61/86] generate --- package.json | 2 +- .../gatewayevm.t.sol/gatewayevmtest.go | 2 +- .../gatewayintegrationtest.go | 5048 +++++++++++++++++ .../zevm/gatewayzevm.sol/gatewayzevm.go | 2 +- .../zevm/interfaces.sol/igatewayzevmevents.go | 476 ++ .../zevm/senderzevm.sol/senderzevm.go | 2 +- pkg/contracts/zevm/interfaces.sol/izrc20.go | 1415 ----- .../zevm/interfaces.sol/izrc20metadata.go | 1508 ----- .../isystem.sol}/isystem.go | 2 +- .../zevm/interfaces/izrc20.sol/isystem.go | 367 ++ .../zevm/interfaces/izrc20.sol/izrc20.go | 1048 +--- .../interfaces/izrc20.sol/izrc20metadata.go | 556 ++ .../zevm/interfaces/izrc20.sol/zrc20events.go | 1185 ++++ .../zevm/systemcontract.sol/systemcontract.go | 2 +- .../systemcontractmock.go | 2 +- pkg/contracts/zevm/zrc20.sol/zrc20.go | 12 +- .../zevm/zrc20new.sol/zrc20errors.go | 0 .../zevm/zrc20new.sol/zrc20new.go | 12 +- .../contracts/prototypes/evm/index.ts | 2 - typechain-types/contracts/prototypes/index.ts | 2 + .../test/GatewayEVM.t.sol/GatewayEVMTest.ts | 1023 ++++ .../prototypes/test/GatewayEVM.t.sol/index.ts | 4 + .../GatewayIntegrationTest.ts | 1078 ++++ .../test/GatewayIntegration.t.sol/index.ts | 4 + .../contracts/prototypes/test/index.ts | 7 + .../contracts/prototypes/zevm/index.ts | 2 - .../zevm/interfaces.sol/IGatewayZEVMEvents.ts | 114 + .../prototypes/zevm/interfaces.sol/index.ts | 1 + .../contracts/zevm/ZRC20.sol/ZRC20.ts | 6 +- .../zevm/ZRC20New.sol/ZRC20Errors.ts | 56 + .../contracts/zevm/ZRC20New.sol/ZRC20New.ts | 854 +++ .../contracts/zevm/ZRC20New.sol/index.ts | 5 + typechain-types/contracts/zevm/index.ts | 4 +- .../contracts/zevm/interfaces/ISystem.ts | 243 + .../zevm/interfaces/IZRC20.sol/ISystem.ts | 243 + .../zevm/interfaces/IZRC20.sol/IZRC20.ts | 432 ++ .../interfaces/IZRC20.sol/IZRC20Metadata.ts | 474 ++ .../zevm/interfaces/IZRC20.sol/ZRC20Events.ts | 219 + .../zevm/interfaces/IZRC20.sol/index.ts | 7 + .../contracts/zevm/interfaces/index.ts | 4 +- .../contracts/prototypes/evm/index.ts | 1 - .../factories/contracts/prototypes/index.ts | 1 + .../GatewayEVMTest__factory.ts | 910 +++ .../prototypes/test/GatewayEVM.t.sol/index.ts | 4 + .../GatewayIntegrationTest__factory.ts | 982 ++++ .../test/GatewayIntegration.t.sol/index.ts | 4 + .../contracts/prototypes/test/index.ts | 5 + .../prototypes/zevm/GatewayZEVM__factory.ts | 2 +- .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../contracts/prototypes/zevm/index.ts | 1 - .../IGatewayZEVMEvents__factory.ts | 94 + .../prototypes/zevm/interfaces.sol/index.ts | 1 + .../SystemContract__factory.ts | 2 +- .../zevm/ZRC20.sol/ZRC20__factory.ts | 4 +- .../zevm/ZRC20New.sol/ZRC20Errors__factory.ts | 66 + .../zevm/ZRC20New.sol/ZRC20New__factory.ts | 730 +++ .../contracts/zevm/ZRC20New.sol/index.ts | 5 + .../factories/contracts/zevm/index.ts | 2 +- .../zevm/interfaces/ISystem__factory.ts | 122 + .../interfaces/IZRC20.sol/ISystem__factory.ts | 122 + .../IZRC20.sol/IZRC20Metadata__factory.ts | 296 + .../interfaces/IZRC20.sol/IZRC20__factory.ts | 254 + .../IZRC20.sol/ZRC20Events__factory.ts | 177 + .../zevm/interfaces/IZRC20.sol/index.ts | 7 + .../contracts/zevm/interfaces/index.ts | 3 +- .../SystemContractMock__factory.ts | 2 +- typechain-types/hardhat.d.ts | 117 +- typechain-types/index.ts | 30 +- 68 files changed, 16305 insertions(+), 4066 deletions(-) rename pkg/contracts/prototypes/{evm => test}/gatewayevm.t.sol/gatewayevmtest.go (99%) create mode 100644 pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go create mode 100644 pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go delete mode 100644 pkg/contracts/zevm/interfaces.sol/izrc20.go delete mode 100644 pkg/contracts/zevm/interfaces.sol/izrc20metadata.go rename pkg/contracts/zevm/{interfaces.sol => interfaces/isystem.sol}/isystem.go (99%) create mode 100644 pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go create mode 100644 pkg/contracts/zevm/interfaces/izrc20.sol/izrc20metadata.go create mode 100644 pkg/contracts/zevm/interfaces/izrc20.sol/zrc20events.go rename pkg/contracts/{prototypes => }/zevm/zrc20new.sol/zrc20errors.go (100%) rename pkg/contracts/{prototypes => }/zevm/zrc20new.sol/zrc20new.go (99%) create mode 100644 typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest.ts create mode 100644 typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest.ts create mode 100644 typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/test/index.ts create mode 100644 typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts create mode 100644 typechain-types/contracts/zevm/ZRC20New.sol/ZRC20Errors.ts create mode 100644 typechain-types/contracts/zevm/ZRC20New.sol/ZRC20New.ts create mode 100644 typechain-types/contracts/zevm/ZRC20New.sol/index.ts create mode 100644 typechain-types/contracts/zevm/interfaces/ISystem.ts create mode 100644 typechain-types/contracts/zevm/interfaces/IZRC20.sol/ISystem.ts create mode 100644 typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20.ts create mode 100644 typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata.ts create mode 100644 typechain-types/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events.ts create mode 100644 typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20Errors__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/ZRC20New.sol/index.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/ISystem__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ISystem__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events__factory.ts create mode 100644 typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts diff --git a/package.json b/package.json index 42165105..c5fd3a62 100644 --- a/package.json +++ b/package.json @@ -84,7 +84,7 @@ "docs": "forge doc", "generate": "yarn compile && ./scripts/generate_go.sh || true && ./scripts/generate_addresses.sh && yarn lint:fix", "lint": "npx eslint . --ext .js,.ts", - "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json --ignore-pattern lib/forge-std/ --ignore-pattern out", + "lint:fix": "npx eslint . --ext .js,.ts,.json --fix --ignore-pattern coverage/ --ignore-pattern coverage.json --ignore-pattern lib/forge-std/ --ignore-pattern out --ignore-pattern cache_forge/", "lint:sol": "solhint 'contracts/**/*.sol'", "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"", "prepublishOnly": "yarn build", diff --git a/pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go similarity index 99% rename from pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go rename to pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go index 69483950..5a7938c4 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.t.sol/gatewayevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. var GatewayEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go b/pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go new file mode 100644 index 00000000..5b272e90 --- /dev/null +++ b/pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go @@ -0,0 +1,5048 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package gatewayintegration + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// StdInvariantFuzzArtifactSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzArtifactSelector struct { + Artifact string + Selectors [][4]byte +} + +// StdInvariantFuzzInterface is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzInterface struct { + Addr common.Address + Artifacts []string +} + +// StdInvariantFuzzSelector is an auto generated low-level Go binding around an user-defined struct. +type StdInvariantFuzzSelector struct { + Addr common.Address + Selectors [][4]byte +} + +// GatewayIntegrationTestMetaData contains all meta data concerning the GatewayIntegrationTest contract. +var GatewayIntegrationTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", +} + +// GatewayIntegrationTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayIntegrationTestMetaData.ABI instead. +var GatewayIntegrationTestABI = GatewayIntegrationTestMetaData.ABI + +// GatewayIntegrationTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayIntegrationTestMetaData.Bin instead. +var GatewayIntegrationTestBin = GatewayIntegrationTestMetaData.Bin + +// DeployGatewayIntegrationTest deploys a new Ethereum contract, binding an instance of GatewayIntegrationTest to it. +func DeployGatewayIntegrationTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayIntegrationTest, error) { + parsed, err := GatewayIntegrationTestMetaData.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(GatewayIntegrationTestBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &GatewayIntegrationTest{GatewayIntegrationTestCaller: GatewayIntegrationTestCaller{contract: contract}, GatewayIntegrationTestTransactor: GatewayIntegrationTestTransactor{contract: contract}, GatewayIntegrationTestFilterer: GatewayIntegrationTestFilterer{contract: contract}}, nil +} + +// GatewayIntegrationTest is an auto generated Go binding around an Ethereum contract. +type GatewayIntegrationTest struct { + GatewayIntegrationTestCaller // Read-only binding to the contract + GatewayIntegrationTestTransactor // Write-only binding to the contract + GatewayIntegrationTestFilterer // Log filterer for contract events +} + +// GatewayIntegrationTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayIntegrationTestCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayIntegrationTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayIntegrationTestTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayIntegrationTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayIntegrationTestFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// GatewayIntegrationTestSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type GatewayIntegrationTestSession struct { + Contract *GatewayIntegrationTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayIntegrationTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type GatewayIntegrationTestCallerSession struct { + Contract *GatewayIntegrationTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// GatewayIntegrationTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type GatewayIntegrationTestTransactorSession struct { + Contract *GatewayIntegrationTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// GatewayIntegrationTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayIntegrationTestRaw struct { + Contract *GatewayIntegrationTest // Generic contract binding to access the raw methods on +} + +// GatewayIntegrationTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayIntegrationTestCallerRaw struct { + Contract *GatewayIntegrationTestCaller // Generic read-only contract binding to access the raw methods on +} + +// GatewayIntegrationTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayIntegrationTestTransactorRaw struct { + Contract *GatewayIntegrationTestTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewGatewayIntegrationTest creates a new instance of GatewayIntegrationTest, bound to a specific deployed contract. +func NewGatewayIntegrationTest(address common.Address, backend bind.ContractBackend) (*GatewayIntegrationTest, error) { + contract, err := bindGatewayIntegrationTest(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &GatewayIntegrationTest{GatewayIntegrationTestCaller: GatewayIntegrationTestCaller{contract: contract}, GatewayIntegrationTestTransactor: GatewayIntegrationTestTransactor{contract: contract}, GatewayIntegrationTestFilterer: GatewayIntegrationTestFilterer{contract: contract}}, nil +} + +// NewGatewayIntegrationTestCaller creates a new read-only instance of GatewayIntegrationTest, bound to a specific deployed contract. +func NewGatewayIntegrationTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayIntegrationTestCaller, error) { + contract, err := bindGatewayIntegrationTest(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestCaller{contract: contract}, nil +} + +// NewGatewayIntegrationTestTransactor creates a new write-only instance of GatewayIntegrationTest, bound to a specific deployed contract. +func NewGatewayIntegrationTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayIntegrationTestTransactor, error) { + contract, err := bindGatewayIntegrationTest(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestTransactor{contract: contract}, nil +} + +// NewGatewayIntegrationTestFilterer creates a new log filterer instance of GatewayIntegrationTest, bound to a specific deployed contract. +func NewGatewayIntegrationTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayIntegrationTestFilterer, error) { + contract, err := bindGatewayIntegrationTest(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestFilterer{contract: contract}, nil +} + +// bindGatewayIntegrationTest binds a generic wrapper to an already deployed contract. +func bindGatewayIntegrationTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayIntegrationTestMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayIntegrationTest.Contract.GatewayIntegrationTestCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.GatewayIntegrationTestTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.GatewayIntegrationTestTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayIntegrationTest.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.contract.Transact(opts, method, params...) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "IS_TEST") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ISTEST() (bool, error) { + return _GatewayIntegrationTest.Contract.ISTEST(&_GatewayIntegrationTest.CallOpts) +} + +// ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. +// +// Solidity: function IS_TEST() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ISTEST() (bool, error) { + return _GatewayIntegrationTest.Contract.ISTEST(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeArtifacts() ([]string, error) { + return _GatewayIntegrationTest.Contract.ExcludeArtifacts(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. +// +// Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeArtifacts() ([]string, error) { + return _GatewayIntegrationTest.Contract.ExcludeArtifacts(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.ExcludeContracts(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. +// +// Solidity: function excludeContracts() view returns(address[] excludedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.ExcludeContracts(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayIntegrationTest.Contract.ExcludeSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. +// +// Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayIntegrationTest.Contract.ExcludeSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.ExcludeSenders(&_GatewayIntegrationTest.CallOpts) +} + +// ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. +// +// Solidity: function excludeSenders() view returns(address[] excludedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.ExcludeSenders(&_GatewayIntegrationTest.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) Failed(opts *bind.CallOpts) (bool, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "failed") + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) Failed() (bool, error) { + return _GatewayIntegrationTest.Contract.Failed(&_GatewayIntegrationTest.CallOpts) +} + +// Failed is a free data retrieval call binding the contract method 0xba414fa6. +// +// Solidity: function failed() view returns(bool) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) Failed() (bool, error) { + return _GatewayIntegrationTest.Contract.Failed(&_GatewayIntegrationTest.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetArtifactSelectors") + + if err != nil { + return *new([]StdInvariantFuzzArtifactSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzArtifactSelector)).(*[]StdInvariantFuzzArtifactSelector) + + return out0, err + +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayIntegrationTest.Contract.TargetArtifactSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. +// +// Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayIntegrationTest.Contract.TargetArtifactSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetArtifacts") + + if err != nil { + return *new([]string), err + } + + out0 := *abi.ConvertType(out[0], new([]string)).(*[]string) + + return out0, err + +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetArtifacts() ([]string, error) { + return _GatewayIntegrationTest.Contract.TargetArtifacts(&_GatewayIntegrationTest.CallOpts) +} + +// TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. +// +// Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetArtifacts() ([]string, error) { + return _GatewayIntegrationTest.Contract.TargetArtifacts(&_GatewayIntegrationTest.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetContracts") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetContracts() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.TargetContracts(&_GatewayIntegrationTest.CallOpts) +} + +// TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. +// +// Solidity: function targetContracts() view returns(address[] targetedContracts_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetContracts() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.TargetContracts(&_GatewayIntegrationTest.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetInterfaces") + + if err != nil { + return *new([]StdInvariantFuzzInterface), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzInterface)).(*[]StdInvariantFuzzInterface) + + return out0, err + +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayIntegrationTest.Contract.TargetInterfaces(&_GatewayIntegrationTest.CallOpts) +} + +// TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. +// +// Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayIntegrationTest.Contract.TargetInterfaces(&_GatewayIntegrationTest.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetSelectors") + + if err != nil { + return *new([]StdInvariantFuzzSelector), err + } + + out0 := *abi.ConvertType(out[0], new([]StdInvariantFuzzSelector)).(*[]StdInvariantFuzzSelector) + + return out0, err + +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayIntegrationTest.Contract.TargetSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. +// +// Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayIntegrationTest.Contract.TargetSelectors(&_GatewayIntegrationTest.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { + var out []interface{} + err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetSenders") + + if err != nil { + return *new([]common.Address), err + } + + out0 := *abi.ConvertType(out[0], new([]common.Address)).(*[]common.Address) + + return out0, err + +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetSenders() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.TargetSenders(&_GatewayIntegrationTest.CallOpts) +} + +// TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. +// +// Solidity: function targetSenders() view returns(address[] targetedSenders_) +func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetSenders() ([]common.Address, error) { + return _GatewayIntegrationTest.Contract.TargetSenders(&_GatewayIntegrationTest.CallOpts) +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayIntegrationTest.contract.Transact(opts, "setUp") +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) SetUp() (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.SetUp(&_GatewayIntegrationTest.TransactOpts) +} + +// SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. +// +// Solidity: function setUp() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorSession) SetUp() (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.SetUp(&_GatewayIntegrationTest.TransactOpts) +} + +// TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. +// +// Solidity: function testCallReceiverEVMFromZEVM() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactor) TestCallReceiverEVMFromZEVM(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayIntegrationTest.contract.Transact(opts, "testCallReceiverEVMFromZEVM") +} + +// TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. +// +// Solidity: function testCallReceiverEVMFromZEVM() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayIntegrationTest.TransactOpts) +} + +// TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. +// +// Solidity: function testCallReceiverEVMFromZEVM() returns() +func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { + return _GatewayIntegrationTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayIntegrationTest.TransactOpts) +} + +// GatewayIntegrationTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestCallIterator struct { + Event *GatewayIntegrationTestCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestCall represents a Call event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestCall struct { + Sender common.Address + Receiver []byte + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address) (*GatewayIntegrationTestCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Call", senderRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestCallIterator{contract: _GatewayIntegrationTest.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestCall, sender []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Call", senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestCall) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseCall(log types.Log) (*GatewayIntegrationTestCall, error) { + event := new(GatewayIntegrationTestCall) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestCall0Iterator is returned from FilterCall0 and is used to iterate over the raw logs and unpacked data for Call0 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestCall0Iterator struct { + Event *GatewayIntegrationTestCall0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestCall0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestCall0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestCall0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestCall0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestCall0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestCall0 represents a Call0 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestCall0 struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall0 is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterCall0(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayIntegrationTestCall0Iterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Call0", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestCall0Iterator{contract: _GatewayIntegrationTest.contract, event: "Call0", logs: logs, sub: sub}, nil +} + +// WatchCall0 is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestCall0, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Call0", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestCall0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call0", 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 +} + +// ParseCall0 is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. +// +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseCall0(log types.Log) (*GatewayIntegrationTestCall0, error) { + event := new(GatewayIntegrationTestCall0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestDepositIterator struct { + Event *GatewayIntegrationTestDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestDeposit represents a Deposit event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayIntegrationTestDepositIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestDepositIterator{contract: _GatewayIntegrationTest.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestDeposit) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. +// +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseDeposit(log types.Log) (*GatewayIntegrationTestDeposit, error) { + event := new(GatewayIntegrationTestDeposit) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestExecutedIterator struct { + Event *GatewayIntegrationTestExecuted // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestExecutedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestExecuted) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestExecutedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestExecutedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestExecuted represents a Executed event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayIntegrationTestExecutedIterator, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestExecutedIterator{contract: _GatewayIntegrationTest.contract, event: "Executed", logs: logs, sub: sub}, nil +} + +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestExecuted, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Executed", destinationRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestExecuted) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Executed", 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 +} + +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. +// +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseExecuted(log types.Log) (*GatewayIntegrationTestExecuted, error) { + event := new(GatewayIntegrationTestExecuted) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Executed", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestExecutedWithERC20Iterator struct { + Event *GatewayIntegrationTestExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayIntegrationTestExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestExecutedWithERC20Iterator{contract: _GatewayIntegrationTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestExecutedWithERC20) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ExecutedWithERC20", 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 +} + +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayIntegrationTestExecutedWithERC20, error) { + event := new(GatewayIntegrationTestExecutedWithERC20) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedERC20Iterator struct { + Event *GatewayIntegrationTestReceivedERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestReceivedERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestReceivedERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestReceivedERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestReceivedERC20 represents a ReceivedERC20 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedERC20 struct { + Sender common.Address + Amount *big.Int + Token common.Address + Destination common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedERC20Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestReceivedERC20Iterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil +} + +// WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedERC20) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedERC20") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestReceivedERC20) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedERC20", 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 +} + +// ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. +// +// Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedERC20(log types.Log) (*GatewayIntegrationTestReceivedERC20, error) { + event := new(GatewayIntegrationTestReceivedERC20) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedNoParamsIterator struct { + Event *GatewayIntegrationTestReceivedNoParams // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestReceivedNoParamsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedNoParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestReceivedNoParamsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestReceivedNoParamsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestReceivedNoParams represents a ReceivedNoParams event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedNoParams struct { + Sender common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedNoParamsIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestReceivedNoParamsIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil +} + +// WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedNoParams) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedNoParams") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestReceivedNoParams) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNoParams", 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 +} + +// ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. +// +// Solidity: event ReceivedNoParams(address sender) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedNoParams(log types.Log) (*GatewayIntegrationTestReceivedNoParams, error) { + event := new(GatewayIntegrationTestReceivedNoParams) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedNonPayableIterator struct { + Event *GatewayIntegrationTestReceivedNonPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestReceivedNonPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedNonPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestReceivedNonPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestReceivedNonPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestReceivedNonPayable represents a ReceivedNonPayable event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedNonPayable struct { + Sender common.Address + Strs []string + Nums []*big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedNonPayableIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestReceivedNonPayableIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedNonPayable) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedNonPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestReceivedNonPayable) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNonPayable", 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 +} + +// ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. +// +// Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedNonPayable(log types.Log) (*GatewayIntegrationTestReceivedNonPayable, error) { + event := new(GatewayIntegrationTestReceivedNonPayable) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedPayableIterator struct { + Event *GatewayIntegrationTestReceivedPayable // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestReceivedPayableIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestReceivedPayable) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestReceivedPayableIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestReceivedPayableIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestReceivedPayable represents a ReceivedPayable event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestReceivedPayable struct { + Sender common.Address + Value *big.Int + Str string + Num *big.Int + Flag bool + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedPayableIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestReceivedPayableIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil +} + +// WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedPayable) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedPayable") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestReceivedPayable) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedPayable", 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 +} + +// ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. +// +// Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedPayable(log types.Log) (*GatewayIntegrationTestReceivedPayable, error) { + event := new(GatewayIntegrationTestReceivedPayable) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestWithdrawalIterator struct { + Event *GatewayIntegrationTestWithdrawal // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestWithdrawalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestWithdrawalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestWithdrawalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestWithdrawal represents a Withdrawal event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestWithdrawal struct { + From common.Address + To []byte + Value *big.Int + Gasfee *big.Int + ProtocolFlatFee *big.Int + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayIntegrationTestWithdrawalIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return &GatewayIntegrationTestWithdrawalIterator{contract: _GatewayIntegrationTest.contract, event: "Withdrawal", logs: logs, sub: sub}, nil +} + +// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestWithdrawal, from []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestWithdrawal) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Withdrawal", 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 +} + +// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseWithdrawal(log types.Log) (*GatewayIntegrationTestWithdrawal, error) { + event := new(GatewayIntegrationTestWithdrawal) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogIterator struct { + Event *GatewayIntegrationTestLog // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLog) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLog represents a Log event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLog struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLog(opts *bind.FilterOpts) (*GatewayIntegrationTestLogIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogIterator{contract: _GatewayIntegrationTest.contract, event: "log", logs: logs, sub: sub}, nil +} + +// WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLog) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLog) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log", 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 +} + +// ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. +// +// Solidity: event log(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLog(log types.Log) (*GatewayIntegrationTestLog, error) { + event := new(GatewayIntegrationTestLog) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogAddressIterator struct { + Event *GatewayIntegrationTestLogAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogAddress represents a LogAddress event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogAddress struct { + Arg0 common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*GatewayIntegrationTestLogAddressIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_address") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogAddressIterator{contract: _GatewayIntegrationTest.contract, event: "log_address", logs: logs, sub: sub}, nil +} + +// WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogAddress) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogAddress) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_address", 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 +} + +// ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. +// +// Solidity: event log_address(address arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogAddress(log types.Log) (*GatewayIntegrationTestLogAddress, error) { + event := new(GatewayIntegrationTestLogAddress) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArrayIterator struct { + Event *GatewayIntegrationTestLogArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogArray represents a LogArray event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArray struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArrayIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogArrayIterator{contract: _GatewayIntegrationTest.contract, event: "log_array", logs: logs, sub: sub}, nil +} + +// WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogArray) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array", 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 +} + +// ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. +// +// Solidity: event log_array(uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray(log types.Log) (*GatewayIntegrationTestLogArray, error) { + event := new(GatewayIntegrationTestLogArray) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArray0Iterator struct { + Event *GatewayIntegrationTestLogArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogArray0 represents a LogArray0 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArray0 struct { + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArray0Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogArray0Iterator{contract: _GatewayIntegrationTest.contract, event: "log_array0", logs: logs, sub: sub}, nil +} + +// WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray0) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogArray0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array0", 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 +} + +// ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. +// +// Solidity: event log_array(int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray0(log types.Log) (*GatewayIntegrationTestLogArray0, error) { + event := new(GatewayIntegrationTestLogArray0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArray1Iterator struct { + Event *GatewayIntegrationTestLogArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogArray1 represents a LogArray1 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogArray1 struct { + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArray1Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogArray1Iterator{contract: _GatewayIntegrationTest.contract, event: "log_array1", logs: logs, sub: sub}, nil +} + +// WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray1) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogArray1) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array1", 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 +} + +// ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. +// +// Solidity: event log_array(address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray1(log types.Log) (*GatewayIntegrationTestLogArray1, error) { + event := new(GatewayIntegrationTestLogArray1) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogBytesIterator struct { + Event *GatewayIntegrationTestLogBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogBytes represents a LogBytes event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogBytes struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*GatewayIntegrationTestLogBytesIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogBytesIterator{contract: _GatewayIntegrationTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogBytes) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogBytes) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes", 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 +} + +// ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. +// +// Solidity: event log_bytes(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogBytes(log types.Log) (*GatewayIntegrationTestLogBytes, error) { + event := new(GatewayIntegrationTestLogBytes) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogBytes32Iterator struct { + Event *GatewayIntegrationTestLogBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogBytes32 represents a LogBytes32 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogBytes32 struct { + Arg0 [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*GatewayIntegrationTestLogBytes32Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogBytes32Iterator{contract: _GatewayIntegrationTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogBytes32) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogBytes32) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes32", 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 +} + +// ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. +// +// Solidity: event log_bytes32(bytes32 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogBytes32(log types.Log) (*GatewayIntegrationTestLogBytes32, error) { + event := new(GatewayIntegrationTestLogBytes32) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogIntIterator struct { + Event *GatewayIntegrationTestLogInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogInt represents a LogInt event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogInt struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogIntIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_int") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_int", logs: logs, sub: sub}, nil +} + +// WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogInt) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_int", 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 +} + +// ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. +// +// Solidity: event log_int(int256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogInt(log types.Log) (*GatewayIntegrationTestLogInt, error) { + event := new(GatewayIntegrationTestLogInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedAddressIterator struct { + Event *GatewayIntegrationTestLogNamedAddress // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedAddressIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedAddress) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedAddressIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedAddressIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedAddress represents a LogNamedAddress event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedAddress struct { + Key string + Val common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedAddressIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedAddressIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil +} + +// WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedAddress) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_address") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedAddress) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_address", 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 +} + +// ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. +// +// Solidity: event log_named_address(string key, address val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedAddress(log types.Log) (*GatewayIntegrationTestLogNamedAddress, error) { + event := new(GatewayIntegrationTestLogNamedAddress) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_address", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArrayIterator struct { + Event *GatewayIntegrationTestLogNamedArray // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedArrayIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedArrayIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedArrayIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedArray represents a LogNamedArray event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArray struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArrayIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedArrayIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedArray) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array", 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 +} + +// ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. +// +// Solidity: event log_named_array(string key, uint256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray(log types.Log) (*GatewayIntegrationTestLogNamedArray, error) { + event := new(GatewayIntegrationTestLogNamedArray) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArray0Iterator struct { + Event *GatewayIntegrationTestLogNamedArray0 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedArray0Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray0) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedArray0Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedArray0Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedArray0 represents a LogNamedArray0 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArray0 struct { + Key string + Val []*big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArray0Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedArray0Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray0) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array0") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedArray0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array0", 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 +} + +// ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. +// +// Solidity: event log_named_array(string key, int256[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray0(log types.Log) (*GatewayIntegrationTestLogNamedArray0, error) { + event := new(GatewayIntegrationTestLogNamedArray0) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArray1Iterator struct { + Event *GatewayIntegrationTestLogNamedArray1 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedArray1Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedArray1) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedArray1Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedArray1Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedArray1 represents a LogNamedArray1 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedArray1 struct { + Key string + Val []common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArray1Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedArray1Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil +} + +// WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray1) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array1") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedArray1) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array1", 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 +} + +// ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. +// +// Solidity: event log_named_array(string key, address[] val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray1(log types.Log) (*GatewayIntegrationTestLogNamedArray1, error) { + event := new(GatewayIntegrationTestLogNamedArray1) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedBytesIterator struct { + Event *GatewayIntegrationTestLogNamedBytes // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedBytesIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedBytes) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedBytesIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedBytesIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedBytes represents a LogNamedBytes event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedBytes struct { + Key string + Val []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedBytesIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedBytesIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedBytes) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_bytes") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedBytes) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes", 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 +} + +// ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. +// +// Solidity: event log_named_bytes(string key, bytes val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedBytes(log types.Log) (*GatewayIntegrationTestLogNamedBytes, error) { + event := new(GatewayIntegrationTestLogNamedBytes) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedBytes32Iterator struct { + Event *GatewayIntegrationTestLogNamedBytes32 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedBytes32) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedBytes32 struct { + Key string + Val [32]byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedBytes32Iterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedBytes32Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil +} + +// WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedBytes32) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_bytes32") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedBytes32) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes32", 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 +} + +// ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. +// +// Solidity: event log_named_bytes32(string key, bytes32 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedBytes32(log types.Log) (*GatewayIntegrationTestLogNamedBytes32, error) { + event := new(GatewayIntegrationTestLogNamedBytes32) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedDecimalIntIterator struct { + Event *GatewayIntegrationTestLogNamedDecimalInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedDecimalInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedDecimalInt struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedDecimalIntIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedDecimalIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedDecimalInt) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_decimal_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedDecimalInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_int", 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 +} + +// ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. +// +// Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*GatewayIntegrationTestLogNamedDecimalInt, error) { + event := new(GatewayIntegrationTestLogNamedDecimalInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedDecimalUintIterator struct { + Event *GatewayIntegrationTestLogNamedDecimalUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedDecimalUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedDecimalUint struct { + Key string + Val *big.Int + Decimals *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedDecimalUintIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedDecimalUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedDecimalUint) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_decimal_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedDecimalUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_uint", 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 +} + +// ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. +// +// Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*GatewayIntegrationTestLogNamedDecimalUint, error) { + event := new(GatewayIntegrationTestLogNamedDecimalUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedIntIterator struct { + Event *GatewayIntegrationTestLogNamedInt // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedIntIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedInt) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedIntIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedIntIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedInt represents a LogNamedInt event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedInt struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedIntIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil +} + +// WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedInt) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_int") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_int", 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 +} + +// ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. +// +// Solidity: event log_named_int(string key, int256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedInt(log types.Log) (*GatewayIntegrationTestLogNamedInt, error) { + event := new(GatewayIntegrationTestLogNamedInt) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_int", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedStringIterator struct { + Event *GatewayIntegrationTestLogNamedString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedString represents a LogNamedString event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedString struct { + Key string + Val string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedStringIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedStringIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil +} + +// WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedString) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedString) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_string", 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 +} + +// ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. +// +// Solidity: event log_named_string(string key, string val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedString(log types.Log) (*GatewayIntegrationTestLogNamedString, error) { + event := new(GatewayIntegrationTestLogNamedString) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedUintIterator struct { + Event *GatewayIntegrationTestLogNamedUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogNamedUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogNamedUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogNamedUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogNamedUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogNamedUint represents a LogNamedUint event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogNamedUint struct { + Key string + Val *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedUintIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogNamedUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil +} + +// WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedUint) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogNamedUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_uint", 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 +} + +// ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. +// +// Solidity: event log_named_uint(string key, uint256 val) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedUint(log types.Log) (*GatewayIntegrationTestLogNamedUint, error) { + event := new(GatewayIntegrationTestLogNamedUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogStringIterator struct { + Event *GatewayIntegrationTestLogString // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogStringIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogString) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogStringIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogStringIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogString represents a LogString event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogString struct { + Arg0 string + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogString(opts *bind.FilterOpts) (*GatewayIntegrationTestLogStringIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_string") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogStringIterator{contract: _GatewayIntegrationTest.contract, event: "log_string", logs: logs, sub: sub}, nil +} + +// WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogString) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_string") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogString) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_string", 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 +} + +// ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. +// +// Solidity: event log_string(string arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogString(log types.Log) (*GatewayIntegrationTestLogString, error) { + event := new(GatewayIntegrationTestLogString) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_string", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogUintIterator struct { + Event *GatewayIntegrationTestLogUint // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogUintIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogUint) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogUintIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogUintIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogUint represents a LogUint event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogUint struct { + Arg0 *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogUintIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_uint", logs: logs, sub: sub}, nil +} + +// WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogUint) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_uint") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_uint", 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 +} + +// ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. +// +// Solidity: event log_uint(uint256 arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogUint(log types.Log) (*GatewayIntegrationTestLogUint, error) { + event := new(GatewayIntegrationTestLogUint) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_uint", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// GatewayIntegrationTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogsIterator struct { + Event *GatewayIntegrationTestLogs // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayIntegrationTestLogsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayIntegrationTestLogs) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayIntegrationTestLogsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayIntegrationTestLogsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayIntegrationTestLogs represents a Logs event raised by the GatewayIntegrationTest contract. +type GatewayIntegrationTestLogs struct { + Arg0 []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogs(opts *bind.FilterOpts) (*GatewayIntegrationTestLogsIterator, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "logs") + if err != nil { + return nil, err + } + return &GatewayIntegrationTestLogsIterator{contract: _GatewayIntegrationTest.contract, event: "logs", logs: logs, sub: sub}, nil +} + +// WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogs) (event.Subscription, error) { + + logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "logs") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayIntegrationTestLogs) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "logs", 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 +} + +// ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. +// +// Solidity: event logs(bytes arg0) +func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogs(log types.Log) (*GatewayIntegrationTestLogs, error) { + event := new(GatewayIntegrationTestLogs) + if err := _GatewayIntegrationTest.contract.UnpackLog(event, "logs", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index a308bbb0..0e7c99f2 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -39,7 +39,7 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c612c726200024360003960008181610433015281816104c2015281816105d40152818161066301526107130152612c726000f3fe6080604052600436106100dd5760003560e01c80637993c1e01161007f578063bcf7f32b11610059578063bcf7f32b14610251578063c39aca371461027a578063f2fde38b146102a3578063f45346dc146102cc576100dd565b80637993c1e0146101e65780638129fc1c1461020f5780638da5cb5b14610226576100dd565b80633ce4a5bc116100bb5780633ce4a5bc1461015d5780634f1ef2861461018857806352d1902d146101a4578063715018a6146101cf576100dd565b80630ac7c44c146100e2578063135390f91461010b5780633659cfe614610134575b600080fd5b3480156100ee57600080fd5b5061010960048036038101906101049190611c80565b6102f5565b005b34801561011757600080fd5b50610132600480360381019061012d9190611cfc565b61034c565b005b34801561014057600080fd5b5061015b60048036038101906101569190611b0a565b610431565b005b34801561016957600080fd5b506101726105ba565b60405161017f919061226e565b60405180910390f35b6101a2600480360381019061019d9190611b37565b6105d2565b005b3480156101b057600080fd5b506101b961070f565b6040516101c691906122e9565b60405180910390f35b3480156101db57600080fd5b506101e46107c8565b005b3480156101f257600080fd5b5061020d60048036038101906102089190611d6b565b6107dc565b005b34801561021b57600080fd5b506102246108c7565b005b34801561023257600080fd5b5061023b610a0d565b604051610248919061226e565b60405180910390f35b34801561025d57600080fd5b5061027860048036038101906102739190611e0f565b610a37565b005b34801561028657600080fd5b506102a1600480360381019061029c9190611e0f565b610b2b565b005b3480156102af57600080fd5b506102ca60048036038101906102c59190611b0a565b610d5d565b005b3480156102d857600080fd5b506102f360048036038101906102ee9190611bd3565b610de1565b005b3373ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f84848460405161033f93929190612304565b60405180910390a2505050565b60006103588383610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8585848673ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156103db57600080fd5b505afa1580156103ef573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104139190611ec5565b60405161042394939291906123a0565b60405180910390a250505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156104c0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104b79061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166104ff61128d565b73ffffffffffffffffffffffffffffffffffffffff1614610555576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161054c9061247c565b60405180910390fd5b61055e816112e4565b6105b781600067ffffffffffffffff81111561057d5761057c61282b565b5b6040519080825280601f01601f1916602001820160405280156105af5781602001600182028036833780820191505090505b5060006112ef565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610661576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106589061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106a061128d565b73ffffffffffffffffffffffffffffffffffffffff16146106f6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106ed9061247c565b60405180910390fd5b6106ff826112e4565b61070b828260016112ef565b5050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161461079f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107969061249c565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b6107d061146c565b6107da60006114ea565b565b60006107e88585610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8787848873ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561086b57600080fd5b505afa15801561087f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108a39190611ec5565b88886040516108b79695949392919061233d565b60405180910390a2505050505050565b60008060019054906101000a900460ff161590508080156108f85750600160008054906101000a900460ff1660ff16105b806109255750610907306115b0565b1580156109245750600160008054906101000a900460ff1660ff16145b5b610964576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161095b906124dc565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109a1576001600060016101000a81548160ff0219169083151502179055505b6109a96115d3565b6109b161162c565b8015610a0a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610a0191906123ff565b60405180910390a15b50565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ab0576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610af195949392919061259c565b600060405180830381600087803b158015610b0b57600080fd5b505af1158015610b1f573d6000803e3d6000fd5b50505050505050505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ba4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161480610c1d57503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610c54576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610c8f9291906122c0565b602060405180830381600087803b158015610ca957600080fd5b505af1158015610cbd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ce19190611c26565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610d2395949392919061259c565b600060405180830381600087803b158015610d3d57600080fd5b505af1158015610d51573d6000803e3d6000fd5b50505050505050505050565b610d6561146c565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610dd5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dcc9061243c565b60405180910390fd5b610dde816114ea565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610e5a576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161480610ed357503073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15610f0a576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff166347e7ef2482846040518363ffffffff1660e01b8152600401610f459291906122c0565b602060405180830381600087803b158015610f5f57600080fd5b505af1158015610f73573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f979190611c26565b50505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1663d9eeebed6040518163ffffffff1660e01b8152600401604080518083038186803b158015610fe757600080fd5b505afa158015610ffb573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061101f9190611b93565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b815260040161107493929190612289565b602060405180830381600087803b15801561108e57600080fd5b505af11580156110a2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110c69190611c26565b6110fc576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166323b872dd3330886040518463ffffffff1660e01b815260040161113993929190612289565b602060405180830381600087803b15801561115357600080fd5b505af1158015611167573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061118b9190611c26565b6111c1576040517f4dd9ee8d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166342966c68866040518263ffffffff1660e01b81526004016111fa91906125f1565b602060405180830381600087803b15801561121457600080fd5b505af1158015611228573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061124c9190611c26565b611282576040517f2c77e05c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b809250505092915050565b60006112bb7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6112ec61146c565b50565b61131b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611687565b60000160009054906101000a900460ff161561133f5761133a83611691565b611467565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561138557600080fd5b505afa9250505080156113b657506040513d601f19601f820116820180604052508101906113b39190611c53565b60015b6113f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113ec906124fc565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b811461145a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611451906124bc565b60405180910390fd5b5061146683838361174a565b5b505050565b611474611776565b73ffffffffffffffffffffffffffffffffffffffff16611492610a0d565b73ffffffffffffffffffffffffffffffffffffffff16146114e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114df9061253c565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611622576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116199061257c565b60405180910390fd5b61162a61177e565b565b600060019054906101000a900460ff1661167b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116729061257c565b60405180910390fd5b565b6000819050919050565b6000819050919050565b61169a816115b0565b6116d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116d09061251c565b60405180910390fd5b806117067f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611753836117df565b6000825111806117605750805b156117715761176f838361182e565b505b505050565b600033905090565b600060019054906101000a900460ff166117cd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117c49061257c565b60405180910390fd5b6117dd6117d8611776565b6114ea565b565b6117e881611691565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606118538383604051806060016040528060278152602001612c166027913961185b565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516118859190612257565b600060405180830381855af49150503d80600081146118c0576040519150601f19603f3d011682016040523d82523d6000602084013e6118c5565b606091505b50915091506118d6868383876118e1565b925050509392505050565b606083156119445760008351141561193c576118fc856115b0565b61193b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119329061255c565b60405180910390fd5b5b82905061194f565b61194e8383611957565b5b949350505050565b60008251111561196a5781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161199e919061241a565b60405180910390fd5b60006119ba6119b584612631565b61260c565b9050828152602081018484840111156119d6576119d5612878565b5b6119e18482856127b8565b509392505050565b6000813590506119f881612bb9565b92915050565b600081519050611a0d81612bb9565b92915050565b600081519050611a2281612bd0565b92915050565b600081519050611a3781612be7565b92915050565b60008083601f840112611a5357611a52612864565b5b8235905067ffffffffffffffff811115611a7057611a6f61285f565b5b602083019150836001820283011115611a8c57611a8b612873565b5b9250929050565b600082601f830112611aa857611aa7612864565b5b8135611ab88482602086016119a7565b91505092915050565b600060608284031215611ad757611ad6612869565b5b81905092915050565b600081359050611aef81612bfe565b92915050565b600081519050611b0481612bfe565b92915050565b600060208284031215611b2057611b1f612887565b5b6000611b2e848285016119e9565b91505092915050565b60008060408385031215611b4e57611b4d612887565b5b6000611b5c858286016119e9565b925050602083013567ffffffffffffffff811115611b7d57611b7c61287d565b5b611b8985828601611a93565b9150509250929050565b60008060408385031215611baa57611ba9612887565b5b6000611bb8858286016119fe565b9250506020611bc985828601611af5565b9150509250929050565b600080600060608486031215611bec57611beb612887565b5b6000611bfa868287016119e9565b9350506020611c0b86828701611ae0565b9250506040611c1c868287016119e9565b9150509250925092565b600060208284031215611c3c57611c3b612887565b5b6000611c4a84828501611a13565b91505092915050565b600060208284031215611c6957611c68612887565b5b6000611c7784828501611a28565b91505092915050565b600080600060408486031215611c9957611c98612887565b5b600084013567ffffffffffffffff811115611cb757611cb661287d565b5b611cc386828701611a93565b935050602084013567ffffffffffffffff811115611ce457611ce361287d565b5b611cf086828701611a3d565b92509250509250925092565b600080600060608486031215611d1557611d14612887565b5b600084013567ffffffffffffffff811115611d3357611d3261287d565b5b611d3f86828701611a93565b9350506020611d5086828701611ae0565b9250506040611d61868287016119e9565b9150509250925092565b600080600080600060808688031215611d8757611d86612887565b5b600086013567ffffffffffffffff811115611da557611da461287d565b5b611db188828901611a93565b9550506020611dc288828901611ae0565b9450506040611dd3888289016119e9565b935050606086013567ffffffffffffffff811115611df457611df361287d565b5b611e0088828901611a3d565b92509250509295509295909350565b60008060008060008060a08789031215611e2c57611e2b612887565b5b600087013567ffffffffffffffff811115611e4a57611e4961287d565b5b611e5689828a01611ac1565b9650506020611e6789828a016119e9565b9550506040611e7889828a01611ae0565b9450506060611e8989828a016119e9565b935050608087013567ffffffffffffffff811115611eaa57611ea961287d565b5b611eb689828a01611a3d565b92509250509295509295509295565b600060208284031215611edb57611eda612887565b5b6000611ee984828501611af5565b91505092915050565b611efb81612747565b82525050565b611f0a81612747565b82525050565b611f1981612765565b82525050565b6000611f2b8385612678565b9350611f388385846127b8565b611f418361288c565b840190509392505050565b6000611f588385612689565b9350611f658385846127b8565b611f6e8361288c565b840190509392505050565b6000611f8482612662565b611f8e8185612689565b9350611f9e8185602086016127c7565b611fa78161288c565b840191505092915050565b6000611fbd82612662565b611fc7818561269a565b9350611fd78185602086016127c7565b80840191505092915050565b611fec816127a6565b82525050565b6000611ffd8261266d565b61200781856126a5565b93506120178185602086016127c7565b6120208161288c565b840191505092915050565b60006120386026836126a5565b91506120438261289d565b604082019050919050565b600061205b602c836126a5565b9150612066826128ec565b604082019050919050565b600061207e602c836126a5565b91506120898261293b565b604082019050919050565b60006120a16038836126a5565b91506120ac8261298a565b604082019050919050565b60006120c46029836126a5565b91506120cf826129d9565b604082019050919050565b60006120e7602e836126a5565b91506120f282612a28565b604082019050919050565b600061210a602e836126a5565b915061211582612a77565b604082019050919050565b600061212d602d836126a5565b915061213882612ac6565b604082019050919050565b60006121506020836126a5565b915061215b82612b15565b602082019050919050565b6000612173600083612689565b915061217e82612b3e565b600082019050919050565b6000612196601d836126a5565b91506121a182612b41565b602082019050919050565b60006121b9602b836126a5565b91506121c482612b6a565b604082019050919050565b6000606083016121e260008401846126cd565b85830360008701526121f5838284611f1f565b9250505061220660208401846126b6565b6122136020860182611ef2565b506122216040840184612730565b61222e6040860182612239565b508091505092915050565b6122428161278f565b82525050565b6122518161278f565b82525050565b60006122638284611fb2565b915081905092915050565b60006020820190506122836000830184611f01565b92915050565b600060608201905061229e6000830186611f01565b6122ab6020830185611f01565b6122b86040830184612248565b949350505050565b60006040820190506122d56000830185611f01565b6122e26020830184612248565b9392505050565b60006020820190506122fe6000830184611f10565b92915050565b6000604082019050818103600083015261231e8186611f79565b90508181036020830152612333818486611f4c565b9050949350505050565b600060a08201905081810360008301526123578189611f79565b90506123666020830188612248565b6123736040830187612248565b6123806060830186612248565b8181036080830152612393818486611f4c565b9050979650505050505050565b600060a08201905081810360008301526123ba8187611f79565b90506123c96020830186612248565b6123d66040830185612248565b6123e36060830184612248565b81810360808301526123f481612166565b905095945050505050565b60006020820190506124146000830184611fe3565b92915050565b600060208201905081810360008301526124348184611ff2565b905092915050565b600060208201905081810360008301526124558161202b565b9050919050565b600060208201905081810360008301526124758161204e565b9050919050565b6000602082019050818103600083015261249581612071565b9050919050565b600060208201905081810360008301526124b581612094565b9050919050565b600060208201905081810360008301526124d5816120b7565b9050919050565b600060208201905081810360008301526124f5816120da565b9050919050565b60006020820190508181036000830152612515816120fd565b9050919050565b6000602082019050818103600083015261253581612120565b9050919050565b6000602082019050818103600083015261255581612143565b9050919050565b6000602082019050818103600083015261257581612189565b9050919050565b60006020820190508181036000830152612595816121ac565b9050919050565b600060808201905081810360008301526125b681886121cf565b90506125c56020830187611f01565b6125d26040830186612248565b81810360608301526125e5818486611f4c565b90509695505050505050565b60006020820190506126066000830184612248565b92915050565b6000612616612627565b905061262282826127fa565b919050565b6000604051905090565b600067ffffffffffffffff82111561264c5761264b61282b565b5b6126558261288c565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006126c560208401846119e9565b905092915050565b600080833560016020038436030381126126ea576126e9612882565b5b83810192508235915060208301925067ffffffffffffffff8211156127125761271161285a565b5b6001820236038413156127285761272761286e565b5b509250929050565b600061273f6020840184611ae0565b905092915050565b60006127528261276f565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006127b182612799565b9050919050565b82818337600083830152505050565b60005b838110156127e55780820151818401526020810190506127ca565b838111156127f4576000848401525b50505050565b6128038261288c565b810181811067ffffffffffffffff821117156128225761282161282b565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b612bc281612747565b8114612bcd57600080fd5b50565b612bd981612759565b8114612be457600080fd5b50565b612bf081612765565b8114612bfb57600080fd5b50565b612c078161278f565b8114612c1257600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220d791071fca3eb6f4d8ee341d9d051caa2cc3da51b34ac59d695c4cced2a1daf464736f6c63430008070033", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go new file mode 100644 index 00000000..2ace4e35 --- /dev/null +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go @@ -0,0 +1,476 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayZEVMEventsMetaData contains all meta data concerning the IGatewayZEVMEvents contract. +var IGatewayZEVMEventsMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"}]", +} + +// IGatewayZEVMEventsABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayZEVMEventsMetaData.ABI instead. +var IGatewayZEVMEventsABI = IGatewayZEVMEventsMetaData.ABI + +// IGatewayZEVMEvents is an auto generated Go binding around an Ethereum contract. +type IGatewayZEVMEvents struct { + IGatewayZEVMEventsCaller // Read-only binding to the contract + IGatewayZEVMEventsTransactor // Write-only binding to the contract + IGatewayZEVMEventsFilterer // Log filterer for contract events +} + +// IGatewayZEVMEventsCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayZEVMEventsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMEventsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayZEVMEventsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMEventsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayZEVMEventsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMEventsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayZEVMEventsSession struct { + Contract *IGatewayZEVMEvents // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMEventsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayZEVMEventsCallerSession struct { + Contract *IGatewayZEVMEventsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayZEVMEventsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayZEVMEventsTransactorSession struct { + Contract *IGatewayZEVMEventsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMEventsRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayZEVMEventsRaw struct { + Contract *IGatewayZEVMEvents // Generic contract binding to access the raw methods on +} + +// IGatewayZEVMEventsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayZEVMEventsCallerRaw struct { + Contract *IGatewayZEVMEventsCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayZEVMEventsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayZEVMEventsTransactorRaw struct { + Contract *IGatewayZEVMEventsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayZEVMEvents creates a new instance of IGatewayZEVMEvents, bound to a specific deployed contract. +func NewIGatewayZEVMEvents(address common.Address, backend bind.ContractBackend) (*IGatewayZEVMEvents, error) { + contract, err := bindIGatewayZEVMEvents(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayZEVMEvents{IGatewayZEVMEventsCaller: IGatewayZEVMEventsCaller{contract: contract}, IGatewayZEVMEventsTransactor: IGatewayZEVMEventsTransactor{contract: contract}, IGatewayZEVMEventsFilterer: IGatewayZEVMEventsFilterer{contract: contract}}, nil +} + +// NewIGatewayZEVMEventsCaller creates a new read-only instance of IGatewayZEVMEvents, bound to a specific deployed contract. +func NewIGatewayZEVMEventsCaller(address common.Address, caller bind.ContractCaller) (*IGatewayZEVMEventsCaller, error) { + contract, err := bindIGatewayZEVMEvents(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMEventsCaller{contract: contract}, nil +} + +// NewIGatewayZEVMEventsTransactor creates a new write-only instance of IGatewayZEVMEvents, bound to a specific deployed contract. +func NewIGatewayZEVMEventsTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayZEVMEventsTransactor, error) { + contract, err := bindIGatewayZEVMEvents(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMEventsTransactor{contract: contract}, nil +} + +// NewIGatewayZEVMEventsFilterer creates a new log filterer instance of IGatewayZEVMEvents, bound to a specific deployed contract. +func NewIGatewayZEVMEventsFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayZEVMEventsFilterer, error) { + contract, err := bindIGatewayZEVMEvents(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayZEVMEventsFilterer{contract: contract}, nil +} + +// bindIGatewayZEVMEvents binds a generic wrapper to an already deployed contract. +func bindIGatewayZEVMEvents(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayZEVMEventsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVMEvents.Contract.IGatewayZEVMEventsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVMEvents.Contract.IGatewayZEVMEventsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVMEvents.Contract.IGatewayZEVMEventsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVMEvents.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVMEvents.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVMEvents *IGatewayZEVMEventsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVMEvents.Contract.contract.Transact(opts, method, params...) +} + +// IGatewayZEVMEventsCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the IGatewayZEVMEvents contract. +type IGatewayZEVMEventsCallIterator struct { + Event *IGatewayZEVMEventsCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayZEVMEventsCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayZEVMEventsCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayZEVMEventsCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayZEVMEventsCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayZEVMEventsCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayZEVMEventsCall represents a Call event raised by the IGatewayZEVMEvents contract. +type IGatewayZEVMEventsCall struct { + Sender common.Address + Receiver []byte + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterCall is a free log retrieval operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address) (*IGatewayZEVMEventsCallIterator, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _IGatewayZEVMEvents.contract.FilterLogs(opts, "Call", senderRule) + if err != nil { + return nil, err + } + return &IGatewayZEVMEventsCallIterator{contract: _IGatewayZEVMEvents.contract, event: "Call", logs: logs, sub: sub}, nil +} + +// WatchCall is a free log subscription operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *IGatewayZEVMEventsCall, sender []common.Address) (event.Subscription, error) { + + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + + logs, sub, err := _IGatewayZEVMEvents.contract.WatchLogs(opts, "Call", senderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayZEVMEventsCall) + if err := _IGatewayZEVMEvents.contract.UnpackLog(event, "Call", 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 +} + +// ParseCall is a log parse operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. +// +// Solidity: event Call(address indexed sender, bytes receiver, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) ParseCall(log types.Log) (*IGatewayZEVMEventsCall, error) { + event := new(IGatewayZEVMEventsCall) + if err := _IGatewayZEVMEvents.contract.UnpackLog(event, "Call", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IGatewayZEVMEventsWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the IGatewayZEVMEvents contract. +type IGatewayZEVMEventsWithdrawalIterator struct { + Event *IGatewayZEVMEventsWithdrawal // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IGatewayZEVMEventsWithdrawalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IGatewayZEVMEventsWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IGatewayZEVMEventsWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IGatewayZEVMEventsWithdrawalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IGatewayZEVMEventsWithdrawalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IGatewayZEVMEventsWithdrawal represents a Withdrawal event raised by the IGatewayZEVMEvents contract. +type IGatewayZEVMEventsWithdrawal struct { + From common.Address + To []byte + Value *big.Int + Gasfee *big.Int + ProtocolFlatFee *big.Int + Message []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*IGatewayZEVMEventsWithdrawalIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _IGatewayZEVMEvents.contract.FilterLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return &IGatewayZEVMEventsWithdrawalIterator{contract: _IGatewayZEVMEvents.contract, event: "Withdrawal", logs: logs, sub: sub}, nil +} + +// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *IGatewayZEVMEventsWithdrawal, from []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _IGatewayZEVMEvents.contract.WatchLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IGatewayZEVMEventsWithdrawal) + if err := _IGatewayZEVMEvents.contract.UnpackLog(event, "Withdrawal", 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 +} + +// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) ParseWithdrawal(log types.Log) (*IGatewayZEVMEventsWithdrawal, error) { + event := new(IGatewayZEVMEventsWithdrawal) + if err := _IGatewayZEVMEvents.contract.UnpackLog(event, "Withdrawal", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 77c21d44..9ee8a64e 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/interfaces.sol/izrc20.go b/pkg/contracts/zevm/interfaces.sol/izrc20.go deleted file mode 100644 index a91456f2..00000000 --- a/pkg/contracts/zevm/interfaces.sol/izrc20.go +++ /dev/null @@ -1,1415 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package interfaces - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// IZRC20MetaData contains all meta data concerning the IZRC20 contract. -var IZRC20MetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// IZRC20ABI is the input ABI used to generate the binding from. -// Deprecated: Use IZRC20MetaData.ABI instead. -var IZRC20ABI = IZRC20MetaData.ABI - -// IZRC20 is an auto generated Go binding around an Ethereum contract. -type IZRC20 struct { - IZRC20Caller // Read-only binding to the contract - IZRC20Transactor // Write-only binding to the contract - IZRC20Filterer // Log filterer for contract events -} - -// IZRC20Caller is an auto generated read-only Go binding around an Ethereum contract. -type IZRC20Caller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20Transactor is an auto generated write-only Go binding around an Ethereum contract. -type IZRC20Transactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. -type IZRC20Filterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20Session is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type IZRC20Session struct { - Contract *IZRC20 // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IZRC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type IZRC20CallerSession struct { - Contract *IZRC20Caller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// IZRC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type IZRC20TransactorSession struct { - Contract *IZRC20Transactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IZRC20Raw is an auto generated low-level Go binding around an Ethereum contract. -type IZRC20Raw struct { - Contract *IZRC20 // Generic contract binding to access the raw methods on -} - -// IZRC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type IZRC20CallerRaw struct { - Contract *IZRC20Caller // Generic read-only contract binding to access the raw methods on -} - -// IZRC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type IZRC20TransactorRaw struct { - Contract *IZRC20Transactor // Generic write-only contract binding to access the raw methods on -} - -// NewIZRC20 creates a new instance of IZRC20, bound to a specific deployed contract. -func NewIZRC20(address common.Address, backend bind.ContractBackend) (*IZRC20, error) { - contract, err := bindIZRC20(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &IZRC20{IZRC20Caller: IZRC20Caller{contract: contract}, IZRC20Transactor: IZRC20Transactor{contract: contract}, IZRC20Filterer: IZRC20Filterer{contract: contract}}, nil -} - -// NewIZRC20Caller creates a new read-only instance of IZRC20, bound to a specific deployed contract. -func NewIZRC20Caller(address common.Address, caller bind.ContractCaller) (*IZRC20Caller, error) { - contract, err := bindIZRC20(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &IZRC20Caller{contract: contract}, nil -} - -// NewIZRC20Transactor creates a new write-only instance of IZRC20, bound to a specific deployed contract. -func NewIZRC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IZRC20Transactor, error) { - contract, err := bindIZRC20(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &IZRC20Transactor{contract: contract}, nil -} - -// NewIZRC20Filterer creates a new log filterer instance of IZRC20, bound to a specific deployed contract. -func NewIZRC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IZRC20Filterer, error) { - contract, err := bindIZRC20(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &IZRC20Filterer{contract: contract}, nil -} - -// bindIZRC20 binds a generic wrapper to an already deployed contract. -func bindIZRC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := IZRC20MetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IZRC20 *IZRC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IZRC20.Contract.IZRC20Caller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IZRC20 *IZRC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IZRC20.Contract.IZRC20Transactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IZRC20 *IZRC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IZRC20.Contract.IZRC20Transactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IZRC20 *IZRC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IZRC20.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IZRC20 *IZRC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IZRC20.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IZRC20 *IZRC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IZRC20.Contract.contract.Transact(opts, method, params...) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20 *IZRC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - var out []interface{} - err := _IZRC20.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 - -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20 *IZRC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _IZRC20.Contract.Allowance(&_IZRC20.CallOpts, owner, spender) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20 *IZRC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _IZRC20.Contract.Allowance(&_IZRC20.CallOpts, owner, spender) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20 *IZRC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { - var out []interface{} - err := _IZRC20.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 - -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20 *IZRC20Session) BalanceOf(account common.Address) (*big.Int, error) { - return _IZRC20.Contract.BalanceOf(&_IZRC20.CallOpts, account) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20 *IZRC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { - return _IZRC20.Contract.BalanceOf(&_IZRC20.CallOpts, account) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20 *IZRC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _IZRC20.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 - -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20 *IZRC20Session) TotalSupply() (*big.Int, error) { - return _IZRC20.Contract.TotalSupply(&_IZRC20.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20 *IZRC20CallerSession) TotalSupply() (*big.Int, error) { - return _IZRC20.Contract.TotalSupply(&_IZRC20.CallOpts) -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20 *IZRC20Caller) WithdrawGasFee(opts *bind.CallOpts) (common.Address, *big.Int, error) { - var out []interface{} - err := _IZRC20.contract.Call(opts, &out, "withdrawGasFee") - - if err != nil { - return *new(common.Address), *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return out0, out1, err - -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20 *IZRC20Session) WithdrawGasFee() (common.Address, *big.Int, error) { - return _IZRC20.Contract.WithdrawGasFee(&_IZRC20.CallOpts) -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20 *IZRC20CallerSession) WithdrawGasFee() (common.Address, *big.Int, error) { - return _IZRC20.Contract.WithdrawGasFee(&_IZRC20.CallOpts) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "approve", spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Approve(&_IZRC20.TransactOpts, spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Approve(&_IZRC20.TransactOpts, spender, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) Deposit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "deposit", to, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Deposit(&_IZRC20.TransactOpts, to, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Deposit(&_IZRC20.TransactOpts, to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "transfer", recipient, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Transfer(&_IZRC20.TransactOpts, recipient, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Transfer(&_IZRC20.TransactOpts, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.TransferFrom(&_IZRC20.TransactOpts, sender, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.TransferFrom(&_IZRC20.TransactOpts, sender, recipient, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) Withdraw(opts *bind.TransactOpts, to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "withdraw", to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Withdraw(&_IZRC20.TransactOpts, to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.Withdraw(&_IZRC20.TransactOpts, to, amount) -} - -// IZRC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IZRC20 contract. -type IZRC20ApprovalIterator struct { - Event *IZRC20Approval // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20ApprovalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20ApprovalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20ApprovalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Approval represents a Approval event raised by the IZRC20 contract. -type IZRC20Approval struct { - Owner common.Address - Spender common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IZRC20ApprovalIterator, 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 := _IZRC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return &IZRC20ApprovalIterator{contract: _IZRC20.contract, event: "Approval", logs: logs, sub: sub}, nil -} - -// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IZRC20Approval, 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 := _IZRC20.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Approval) - if err := _IZRC20.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 -} - -// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseApproval(log types.Log) (*IZRC20Approval, error) { - event := new(IZRC20Approval) - if err := _IZRC20.contract.UnpackLog(event, "Approval", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20DepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the IZRC20 contract. -type IZRC20DepositIterator struct { - Event *IZRC20Deposit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20DepositIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Deposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Deposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20DepositIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20DepositIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Deposit represents a Deposit event raised by the IZRC20 contract. -type IZRC20Deposit struct { - From []byte - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterDeposit is a free log retrieval operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterDeposit(opts *bind.FilterOpts, to []common.Address) (*IZRC20DepositIterator, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return &IZRC20DepositIterator{contract: _IZRC20.contract, event: "Deposit", logs: logs, sub: sub}, nil -} - -// WatchDeposit is a free log subscription operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *IZRC20Deposit, to []common.Address) (event.Subscription, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Deposit) - if err := _IZRC20.contract.UnpackLog(event, "Deposit", 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 -} - -// ParseDeposit is a log parse operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseDeposit(log types.Log) (*IZRC20Deposit, error) { - event := new(IZRC20Deposit) - if err := _IZRC20.contract.UnpackLog(event, "Deposit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IZRC20 contract. -type IZRC20TransferIterator struct { - Event *IZRC20Transfer // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20TransferIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20TransferIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20TransferIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Transfer represents a Transfer event raised by the IZRC20 contract. -type IZRC20Transfer struct { - From common.Address - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IZRC20TransferIterator, 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 := _IZRC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return &IZRC20TransferIterator{contract: _IZRC20.contract, event: "Transfer", logs: logs, sub: sub}, nil -} - -// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IZRC20Transfer, 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 := _IZRC20.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Transfer) - if err := _IZRC20.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 -} - -// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseTransfer(log types.Log) (*IZRC20Transfer, error) { - event := new(IZRC20Transfer) - if err := _IZRC20.contract.UnpackLog(event, "Transfer", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedGasLimitIterator is returned from FilterUpdatedGasLimit and is used to iterate over the raw logs and unpacked data for UpdatedGasLimit events raised by the IZRC20 contract. -type IZRC20UpdatedGasLimitIterator struct { - Event *IZRC20UpdatedGasLimit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedGasLimitIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedGasLimitIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedGasLimitIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedGasLimit represents a UpdatedGasLimit event raised by the IZRC20 contract. -type IZRC20UpdatedGasLimit struct { - GasLimit *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedGasLimit is a free log retrieval operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedGasLimit(opts *bind.FilterOpts) (*IZRC20UpdatedGasLimitIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return &IZRC20UpdatedGasLimitIterator{contract: _IZRC20.contract, event: "UpdatedGasLimit", logs: logs, sub: sub}, nil -} - -// WatchUpdatedGasLimit is a free log subscription operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedGasLimit(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedGasLimit) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedGasLimit) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedGasLimit", 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 -} - -// ParseUpdatedGasLimit is a log parse operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedGasLimit(log types.Log) (*IZRC20UpdatedGasLimit, error) { - event := new(IZRC20UpdatedGasLimit) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedGasLimit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedProtocolFlatFeeIterator is returned from FilterUpdatedProtocolFlatFee and is used to iterate over the raw logs and unpacked data for UpdatedProtocolFlatFee events raised by the IZRC20 contract. -type IZRC20UpdatedProtocolFlatFeeIterator struct { - Event *IZRC20UpdatedProtocolFlatFee // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedProtocolFlatFee represents a UpdatedProtocolFlatFee event raised by the IZRC20 contract. -type IZRC20UpdatedProtocolFlatFee struct { - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedProtocolFlatFee is a free log retrieval operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedProtocolFlatFee(opts *bind.FilterOpts) (*IZRC20UpdatedProtocolFlatFeeIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return &IZRC20UpdatedProtocolFlatFeeIterator{contract: _IZRC20.contract, event: "UpdatedProtocolFlatFee", logs: logs, sub: sub}, nil -} - -// WatchUpdatedProtocolFlatFee is a free log subscription operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedProtocolFlatFee(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedProtocolFlatFee) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedProtocolFlatFee) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedProtocolFlatFee", 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 -} - -// ParseUpdatedProtocolFlatFee is a log parse operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedProtocolFlatFee(log types.Log) (*IZRC20UpdatedProtocolFlatFee, error) { - event := new(IZRC20UpdatedProtocolFlatFee) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedProtocolFlatFee", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedSystemContractIterator is returned from FilterUpdatedSystemContract and is used to iterate over the raw logs and unpacked data for UpdatedSystemContract events raised by the IZRC20 contract. -type IZRC20UpdatedSystemContractIterator struct { - Event *IZRC20UpdatedSystemContract // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedSystemContractIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedSystemContractIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedSystemContractIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedSystemContract represents a UpdatedSystemContract event raised by the IZRC20 contract. -type IZRC20UpdatedSystemContract struct { - SystemContract common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedSystemContract is a free log retrieval operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedSystemContract(opts *bind.FilterOpts) (*IZRC20UpdatedSystemContractIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return &IZRC20UpdatedSystemContractIterator{contract: _IZRC20.contract, event: "UpdatedSystemContract", logs: logs, sub: sub}, nil -} - -// WatchUpdatedSystemContract is a free log subscription operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedSystemContract(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedSystemContract) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedSystemContract) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedSystemContract", 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 -} - -// ParseUpdatedSystemContract is a log parse operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedSystemContract(log types.Log) (*IZRC20UpdatedSystemContract, error) { - event := new(IZRC20UpdatedSystemContract) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedSystemContract", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20WithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the IZRC20 contract. -type IZRC20WithdrawalIterator struct { - Event *IZRC20Withdrawal // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20WithdrawalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Withdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Withdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20WithdrawalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20WithdrawalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Withdrawal represents a Withdrawal event raised by the IZRC20 contract. -type IZRC20Withdrawal struct { - From common.Address - To []byte - Value *big.Int - Gasfee *big.Int - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*IZRC20WithdrawalIterator, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return &IZRC20WithdrawalIterator{contract: _IZRC20.contract, event: "Withdrawal", logs: logs, sub: sub}, nil -} - -// WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *IZRC20Withdrawal, from []common.Address) (event.Subscription, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Withdrawal) - if err := _IZRC20.contract.UnpackLog(event, "Withdrawal", 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 -} - -// ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) ParseWithdrawal(log types.Log) (*IZRC20Withdrawal, error) { - event := new(IZRC20Withdrawal) - if err := _IZRC20.contract.UnpackLog(event, "Withdrawal", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/zevm/interfaces.sol/izrc20metadata.go b/pkg/contracts/zevm/interfaces.sol/izrc20metadata.go deleted file mode 100644 index 753d36cd..00000000 --- a/pkg/contracts/zevm/interfaces.sol/izrc20metadata.go +++ /dev/null @@ -1,1508 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package interfaces - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// IZRC20MetadataMetaData contains all meta data concerning the IZRC20Metadata contract. -var IZRC20MetadataMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// IZRC20MetadataABI is the input ABI used to generate the binding from. -// Deprecated: Use IZRC20MetadataMetaData.ABI instead. -var IZRC20MetadataABI = IZRC20MetadataMetaData.ABI - -// IZRC20Metadata is an auto generated Go binding around an Ethereum contract. -type IZRC20Metadata struct { - IZRC20MetadataCaller // Read-only binding to the contract - IZRC20MetadataTransactor // Write-only binding to the contract - IZRC20MetadataFilterer // Log filterer for contract events -} - -// IZRC20MetadataCaller is an auto generated read-only Go binding around an Ethereum contract. -type IZRC20MetadataCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20MetadataTransactor is an auto generated write-only Go binding around an Ethereum contract. -type IZRC20MetadataTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20MetadataFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type IZRC20MetadataFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// IZRC20MetadataSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type IZRC20MetadataSession struct { - Contract *IZRC20Metadata // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IZRC20MetadataCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type IZRC20MetadataCallerSession struct { - Contract *IZRC20MetadataCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// IZRC20MetadataTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type IZRC20MetadataTransactorSession struct { - Contract *IZRC20MetadataTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// IZRC20MetadataRaw is an auto generated low-level Go binding around an Ethereum contract. -type IZRC20MetadataRaw struct { - Contract *IZRC20Metadata // Generic contract binding to access the raw methods on -} - -// IZRC20MetadataCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type IZRC20MetadataCallerRaw struct { - Contract *IZRC20MetadataCaller // Generic read-only contract binding to access the raw methods on -} - -// IZRC20MetadataTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type IZRC20MetadataTransactorRaw struct { - Contract *IZRC20MetadataTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewIZRC20Metadata creates a new instance of IZRC20Metadata, bound to a specific deployed contract. -func NewIZRC20Metadata(address common.Address, backend bind.ContractBackend) (*IZRC20Metadata, error) { - contract, err := bindIZRC20Metadata(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &IZRC20Metadata{IZRC20MetadataCaller: IZRC20MetadataCaller{contract: contract}, IZRC20MetadataTransactor: IZRC20MetadataTransactor{contract: contract}, IZRC20MetadataFilterer: IZRC20MetadataFilterer{contract: contract}}, nil -} - -// NewIZRC20MetadataCaller creates a new read-only instance of IZRC20Metadata, bound to a specific deployed contract. -func NewIZRC20MetadataCaller(address common.Address, caller bind.ContractCaller) (*IZRC20MetadataCaller, error) { - contract, err := bindIZRC20Metadata(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &IZRC20MetadataCaller{contract: contract}, nil -} - -// NewIZRC20MetadataTransactor creates a new write-only instance of IZRC20Metadata, bound to a specific deployed contract. -func NewIZRC20MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IZRC20MetadataTransactor, error) { - contract, err := bindIZRC20Metadata(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &IZRC20MetadataTransactor{contract: contract}, nil -} - -// NewIZRC20MetadataFilterer creates a new log filterer instance of IZRC20Metadata, bound to a specific deployed contract. -func NewIZRC20MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IZRC20MetadataFilterer, error) { - contract, err := bindIZRC20Metadata(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &IZRC20MetadataFilterer{contract: contract}, nil -} - -// bindIZRC20Metadata binds a generic wrapper to an already deployed contract. -func bindIZRC20Metadata(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := IZRC20MetadataMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IZRC20Metadata *IZRC20MetadataRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IZRC20Metadata.Contract.IZRC20MetadataCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IZRC20Metadata *IZRC20MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.IZRC20MetadataTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IZRC20Metadata *IZRC20MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.IZRC20MetadataTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IZRC20Metadata *IZRC20MetadataCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _IZRC20Metadata.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IZRC20Metadata *IZRC20MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_IZRC20Metadata *IZRC20MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.contract.Transact(opts, method, params...) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { - var out []interface{} - err := _IZRC20Metadata.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 - -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _IZRC20Metadata.Contract.Allowance(&_IZRC20Metadata.CallOpts, owner, spender) -} - -// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. -// -// Solidity: function allowance(address owner, address spender) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { - return _IZRC20Metadata.Contract.Allowance(&_IZRC20Metadata.CallOpts, owner, spender) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { - var out []interface{} - err := _IZRC20Metadata.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 - -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataSession) BalanceOf(account common.Address) (*big.Int, error) { - return _IZRC20Metadata.Contract.BalanceOf(&_IZRC20Metadata.CallOpts, account) -} - -// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. -// -// Solidity: function balanceOf(address account) view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) BalanceOf(account common.Address) (*big.Int, error) { - return _IZRC20Metadata.Contract.BalanceOf(&_IZRC20Metadata.CallOpts, account) -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_IZRC20Metadata *IZRC20MetadataCaller) Decimals(opts *bind.CallOpts) (uint8, error) { - var out []interface{} - err := _IZRC20Metadata.contract.Call(opts, &out, "decimals") - - if err != nil { - return *new(uint8), err - } - - out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) - - return out0, err - -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_IZRC20Metadata *IZRC20MetadataSession) Decimals() (uint8, error) { - return _IZRC20Metadata.Contract.Decimals(&_IZRC20Metadata.CallOpts) -} - -// Decimals is a free data retrieval call binding the contract method 0x313ce567. -// -// Solidity: function decimals() view returns(uint8) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) Decimals() (uint8, error) { - return _IZRC20Metadata.Contract.Decimals(&_IZRC20Metadata.CallOpts) -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataCaller) Name(opts *bind.CallOpts) (string, error) { - var out []interface{} - err := _IZRC20Metadata.contract.Call(opts, &out, "name") - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataSession) Name() (string, error) { - return _IZRC20Metadata.Contract.Name(&_IZRC20Metadata.CallOpts) -} - -// Name is a free data retrieval call binding the contract method 0x06fdde03. -// -// Solidity: function name() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) Name() (string, error) { - return _IZRC20Metadata.Contract.Name(&_IZRC20Metadata.CallOpts) -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataCaller) Symbol(opts *bind.CallOpts) (string, error) { - var out []interface{} - err := _IZRC20Metadata.contract.Call(opts, &out, "symbol") - - if err != nil { - return *new(string), err - } - - out0 := *abi.ConvertType(out[0], new(string)).(*string) - - return out0, err - -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataSession) Symbol() (string, error) { - return _IZRC20Metadata.Contract.Symbol(&_IZRC20Metadata.CallOpts) -} - -// Symbol is a free data retrieval call binding the contract method 0x95d89b41. -// -// Solidity: function symbol() view returns(string) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) Symbol() (string, error) { - return _IZRC20Metadata.Contract.Symbol(&_IZRC20Metadata.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { - var out []interface{} - err := _IZRC20Metadata.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 - -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataSession) TotalSupply() (*big.Int, error) { - return _IZRC20Metadata.Contract.TotalSupply(&_IZRC20Metadata.CallOpts) -} - -// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. -// -// Solidity: function totalSupply() view returns(uint256) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) TotalSupply() (*big.Int, error) { - return _IZRC20Metadata.Contract.TotalSupply(&_IZRC20Metadata.CallOpts) -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20Metadata *IZRC20MetadataCaller) WithdrawGasFee(opts *bind.CallOpts) (common.Address, *big.Int, error) { - var out []interface{} - err := _IZRC20Metadata.contract.Call(opts, &out, "withdrawGasFee") - - if err != nil { - return *new(common.Address), *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) - - return out0, out1, err - -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20Metadata *IZRC20MetadataSession) WithdrawGasFee() (common.Address, *big.Int, error) { - return _IZRC20Metadata.Contract.WithdrawGasFee(&_IZRC20Metadata.CallOpts) -} - -// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. -// -// Solidity: function withdrawGasFee() view returns(address, uint256) -func (_IZRC20Metadata *IZRC20MetadataCallerSession) WithdrawGasFee() (common.Address, *big.Int, error) { - return _IZRC20Metadata.Contract.WithdrawGasFee(&_IZRC20Metadata.CallOpts) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.contract.Transact(opts, "approve", spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Approve(&_IZRC20Metadata.TransactOpts, spender, amount) -} - -// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. -// -// Solidity: function approve(address spender, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Approve(&_IZRC20Metadata.TransactOpts, spender, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactor) Deposit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.contract.Transact(opts, "deposit", to, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Deposit(&_IZRC20Metadata.TransactOpts, to, amount) -} - -// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. -// -// Solidity: function deposit(address to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Deposit(&_IZRC20Metadata.TransactOpts, to, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.contract.Transact(opts, "transfer", recipient, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Transfer(&_IZRC20Metadata.TransactOpts, recipient, amount) -} - -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. -// -// Solidity: function transfer(address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Transfer(&_IZRC20Metadata.TransactOpts, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.contract.Transact(opts, "transferFrom", sender, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.TransferFrom(&_IZRC20Metadata.TransactOpts, sender, recipient, amount) -} - -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. -// -// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.TransferFrom(&_IZRC20Metadata.TransactOpts, sender, recipient, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactor) Withdraw(opts *bind.TransactOpts, to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.contract.Transact(opts, "withdraw", to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Withdraw(&_IZRC20Metadata.TransactOpts, to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. -// -// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) -func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { - return _IZRC20Metadata.Contract.Withdraw(&_IZRC20Metadata.TransactOpts, to, amount) -} - -// IZRC20MetadataApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IZRC20Metadata contract. -type IZRC20MetadataApprovalIterator struct { - Event *IZRC20MetadataApproval // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataApprovalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataApproval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataApproval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataApprovalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataApprovalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataApproval represents a Approval event raised by the IZRC20Metadata contract. -type IZRC20MetadataApproval struct { - Owner common.Address - Spender common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IZRC20MetadataApprovalIterator, 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 := _IZRC20Metadata.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return &IZRC20MetadataApprovalIterator{contract: _IZRC20Metadata.contract, event: "Approval", logs: logs, sub: sub}, nil -} - -// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataApproval, 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 := _IZRC20Metadata.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataApproval) - if err := _IZRC20Metadata.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 -} - -// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseApproval(log types.Log) (*IZRC20MetadataApproval, error) { - event := new(IZRC20MetadataApproval) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Approval", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the IZRC20Metadata contract. -type IZRC20MetadataDepositIterator struct { - Event *IZRC20MetadataDeposit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataDepositIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataDeposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataDeposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataDepositIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataDepositIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataDeposit represents a Deposit event raised by the IZRC20Metadata contract. -type IZRC20MetadataDeposit struct { - From []byte - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterDeposit is a free log retrieval operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterDeposit(opts *bind.FilterOpts, to []common.Address) (*IZRC20MetadataDepositIterator, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20Metadata.contract.FilterLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return &IZRC20MetadataDepositIterator{contract: _IZRC20Metadata.contract, event: "Deposit", logs: logs, sub: sub}, nil -} - -// WatchDeposit is a free log subscription operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataDeposit, to []common.Address) (event.Subscription, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20Metadata.contract.WatchLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataDeposit) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Deposit", 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 -} - -// ParseDeposit is a log parse operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseDeposit(log types.Log) (*IZRC20MetadataDeposit, error) { - event := new(IZRC20MetadataDeposit) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Deposit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IZRC20Metadata contract. -type IZRC20MetadataTransferIterator struct { - Event *IZRC20MetadataTransfer // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataTransferIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataTransfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataTransfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataTransferIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataTransferIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataTransfer represents a Transfer event raised by the IZRC20Metadata contract. -type IZRC20MetadataTransfer struct { - From common.Address - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IZRC20MetadataTransferIterator, 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 := _IZRC20Metadata.contract.FilterLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return &IZRC20MetadataTransferIterator{contract: _IZRC20Metadata.contract, event: "Transfer", logs: logs, sub: sub}, nil -} - -// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataTransfer, 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 := _IZRC20Metadata.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataTransfer) - if err := _IZRC20Metadata.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 -} - -// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseTransfer(log types.Log) (*IZRC20MetadataTransfer, error) { - event := new(IZRC20MetadataTransfer) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Transfer", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataUpdatedGasLimitIterator is returned from FilterUpdatedGasLimit and is used to iterate over the raw logs and unpacked data for UpdatedGasLimit events raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedGasLimitIterator struct { - Event *IZRC20MetadataUpdatedGasLimit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataUpdatedGasLimitIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataUpdatedGasLimitIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataUpdatedGasLimitIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataUpdatedGasLimit represents a UpdatedGasLimit event raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedGasLimit struct { - GasLimit *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedGasLimit is a free log retrieval operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterUpdatedGasLimit(opts *bind.FilterOpts) (*IZRC20MetadataUpdatedGasLimitIterator, error) { - - logs, sub, err := _IZRC20Metadata.contract.FilterLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return &IZRC20MetadataUpdatedGasLimitIterator{contract: _IZRC20Metadata.contract, event: "UpdatedGasLimit", logs: logs, sub: sub}, nil -} - -// WatchUpdatedGasLimit is a free log subscription operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchUpdatedGasLimit(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataUpdatedGasLimit) (event.Subscription, error) { - - logs, sub, err := _IZRC20Metadata.contract.WatchLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataUpdatedGasLimit) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedGasLimit", 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 -} - -// ParseUpdatedGasLimit is a log parse operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseUpdatedGasLimit(log types.Log) (*IZRC20MetadataUpdatedGasLimit, error) { - event := new(IZRC20MetadataUpdatedGasLimit) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedGasLimit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataUpdatedProtocolFlatFeeIterator is returned from FilterUpdatedProtocolFlatFee and is used to iterate over the raw logs and unpacked data for UpdatedProtocolFlatFee events raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedProtocolFlatFeeIterator struct { - Event *IZRC20MetadataUpdatedProtocolFlatFee // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataUpdatedProtocolFlatFeeIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataUpdatedProtocolFlatFeeIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataUpdatedProtocolFlatFeeIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataUpdatedProtocolFlatFee represents a UpdatedProtocolFlatFee event raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedProtocolFlatFee struct { - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedProtocolFlatFee is a free log retrieval operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterUpdatedProtocolFlatFee(opts *bind.FilterOpts) (*IZRC20MetadataUpdatedProtocolFlatFeeIterator, error) { - - logs, sub, err := _IZRC20Metadata.contract.FilterLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return &IZRC20MetadataUpdatedProtocolFlatFeeIterator{contract: _IZRC20Metadata.contract, event: "UpdatedProtocolFlatFee", logs: logs, sub: sub}, nil -} - -// WatchUpdatedProtocolFlatFee is a free log subscription operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchUpdatedProtocolFlatFee(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataUpdatedProtocolFlatFee) (event.Subscription, error) { - - logs, sub, err := _IZRC20Metadata.contract.WatchLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataUpdatedProtocolFlatFee) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedProtocolFlatFee", 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 -} - -// ParseUpdatedProtocolFlatFee is a log parse operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseUpdatedProtocolFlatFee(log types.Log) (*IZRC20MetadataUpdatedProtocolFlatFee, error) { - event := new(IZRC20MetadataUpdatedProtocolFlatFee) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedProtocolFlatFee", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataUpdatedSystemContractIterator is returned from FilterUpdatedSystemContract and is used to iterate over the raw logs and unpacked data for UpdatedSystemContract events raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedSystemContractIterator struct { - Event *IZRC20MetadataUpdatedSystemContract // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataUpdatedSystemContractIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataUpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataUpdatedSystemContractIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataUpdatedSystemContractIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataUpdatedSystemContract represents a UpdatedSystemContract event raised by the IZRC20Metadata contract. -type IZRC20MetadataUpdatedSystemContract struct { - SystemContract common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedSystemContract is a free log retrieval operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterUpdatedSystemContract(opts *bind.FilterOpts) (*IZRC20MetadataUpdatedSystemContractIterator, error) { - - logs, sub, err := _IZRC20Metadata.contract.FilterLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return &IZRC20MetadataUpdatedSystemContractIterator{contract: _IZRC20Metadata.contract, event: "UpdatedSystemContract", logs: logs, sub: sub}, nil -} - -// WatchUpdatedSystemContract is a free log subscription operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchUpdatedSystemContract(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataUpdatedSystemContract) (event.Subscription, error) { - - logs, sub, err := _IZRC20Metadata.contract.WatchLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataUpdatedSystemContract) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedSystemContract", 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 -} - -// ParseUpdatedSystemContract is a log parse operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseUpdatedSystemContract(log types.Log) (*IZRC20MetadataUpdatedSystemContract, error) { - event := new(IZRC20MetadataUpdatedSystemContract) - if err := _IZRC20Metadata.contract.UnpackLog(event, "UpdatedSystemContract", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20MetadataWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the IZRC20Metadata contract. -type IZRC20MetadataWithdrawalIterator struct { - Event *IZRC20MetadataWithdrawal // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20MetadataWithdrawalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataWithdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20MetadataWithdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20MetadataWithdrawalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20MetadataWithdrawalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20MetadataWithdrawal represents a Withdrawal event raised by the IZRC20Metadata contract. -type IZRC20MetadataWithdrawal struct { - From common.Address - To []byte - Value *big.Int - Gasfee *big.Int - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*IZRC20MetadataWithdrawalIterator, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20Metadata.contract.FilterLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return &IZRC20MetadataWithdrawalIterator{contract: _IZRC20Metadata.contract, event: "Withdrawal", logs: logs, sub: sub}, nil -} - -// WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *IZRC20MetadataWithdrawal, from []common.Address) (event.Subscription, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20Metadata.contract.WatchLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20MetadataWithdrawal) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Withdrawal", 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 -} - -// ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) -func (_IZRC20Metadata *IZRC20MetadataFilterer) ParseWithdrawal(log types.Log) (*IZRC20MetadataWithdrawal, error) { - event := new(IZRC20MetadataWithdrawal) - if err := _IZRC20Metadata.contract.UnpackLog(event, "Withdrawal", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/zevm/interfaces.sol/isystem.go b/pkg/contracts/zevm/interfaces/isystem.sol/isystem.go similarity index 99% rename from pkg/contracts/zevm/interfaces.sol/isystem.go rename to pkg/contracts/zevm/interfaces/isystem.sol/isystem.go index a28a3cef..3291465d 100644 --- a/pkg/contracts/zevm/interfaces.sol/isystem.go +++ b/pkg/contracts/zevm/interfaces/isystem.sol/isystem.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package isystem import ( "errors" diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go b/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go new file mode 100644 index 00000000..f0e5f8d1 --- /dev/null +++ b/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go @@ -0,0 +1,367 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package izrc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ISystemMetaData contains all meta data concerning the ISystem contract. +var ISystemMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// ISystemABI is the input ABI used to generate the binding from. +// Deprecated: Use ISystemMetaData.ABI instead. +var ISystemABI = ISystemMetaData.ABI + +// ISystem is an auto generated Go binding around an Ethereum contract. +type ISystem struct { + ISystemCaller // Read-only binding to the contract + ISystemTransactor // Write-only binding to the contract + ISystemFilterer // Log filterer for contract events +} + +// ISystemCaller is an auto generated read-only Go binding around an Ethereum contract. +type ISystemCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ISystemTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ISystemTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ISystemFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ISystemFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ISystemSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ISystemSession struct { + Contract *ISystem // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ISystemCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ISystemCallerSession struct { + Contract *ISystemCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ISystemTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ISystemTransactorSession struct { + Contract *ISystemTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ISystemRaw is an auto generated low-level Go binding around an Ethereum contract. +type ISystemRaw struct { + Contract *ISystem // Generic contract binding to access the raw methods on +} + +// ISystemCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ISystemCallerRaw struct { + Contract *ISystemCaller // Generic read-only contract binding to access the raw methods on +} + +// ISystemTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ISystemTransactorRaw struct { + Contract *ISystemTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewISystem creates a new instance of ISystem, bound to a specific deployed contract. +func NewISystem(address common.Address, backend bind.ContractBackend) (*ISystem, error) { + contract, err := bindISystem(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ISystem{ISystemCaller: ISystemCaller{contract: contract}, ISystemTransactor: ISystemTransactor{contract: contract}, ISystemFilterer: ISystemFilterer{contract: contract}}, nil +} + +// NewISystemCaller creates a new read-only instance of ISystem, bound to a specific deployed contract. +func NewISystemCaller(address common.Address, caller bind.ContractCaller) (*ISystemCaller, error) { + contract, err := bindISystem(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ISystemCaller{contract: contract}, nil +} + +// NewISystemTransactor creates a new write-only instance of ISystem, bound to a specific deployed contract. +func NewISystemTransactor(address common.Address, transactor bind.ContractTransactor) (*ISystemTransactor, error) { + contract, err := bindISystem(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ISystemTransactor{contract: contract}, nil +} + +// NewISystemFilterer creates a new log filterer instance of ISystem, bound to a specific deployed contract. +func NewISystemFilterer(address common.Address, filterer bind.ContractFilterer) (*ISystemFilterer, error) { + contract, err := bindISystem(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ISystemFilterer{contract: contract}, nil +} + +// bindISystem binds a generic wrapper to an already deployed contract. +func bindISystem(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ISystemMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ISystem *ISystemRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ISystem.Contract.ISystemCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ISystem *ISystemRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ISystem.Contract.ISystemTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ISystem *ISystemRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ISystem.Contract.ISystemTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ISystem *ISystemCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ISystem.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ISystem *ISystemTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ISystem.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ISystem *ISystemTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ISystem.Contract.contract.Transact(opts, method, params...) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ISystem *ISystemCaller) FUNGIBLEMODULEADDRESS(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "FUNGIBLE_MODULE_ADDRESS") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ISystem *ISystemSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _ISystem.Contract.FUNGIBLEMODULEADDRESS(&_ISystem.CallOpts) +} + +// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. +// +// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) +func (_ISystem *ISystemCallerSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { + return _ISystem.Contract.FUNGIBLEMODULEADDRESS(&_ISystem.CallOpts) +} + +// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. +// +// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemCaller) GasCoinZRC20ByChainId(opts *bind.CallOpts, chainID *big.Int) (common.Address, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "gasCoinZRC20ByChainId", chainID) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. +// +// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemSession) GasCoinZRC20ByChainId(chainID *big.Int) (common.Address, error) { + return _ISystem.Contract.GasCoinZRC20ByChainId(&_ISystem.CallOpts, chainID) +} + +// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. +// +// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemCallerSession) GasCoinZRC20ByChainId(chainID *big.Int) (common.Address, error) { + return _ISystem.Contract.GasCoinZRC20ByChainId(&_ISystem.CallOpts, chainID) +} + +// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. +// +// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) +func (_ISystem *ISystemCaller) GasPriceByChainId(opts *bind.CallOpts, chainID *big.Int) (*big.Int, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "gasPriceByChainId", chainID) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. +// +// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) +func (_ISystem *ISystemSession) GasPriceByChainId(chainID *big.Int) (*big.Int, error) { + return _ISystem.Contract.GasPriceByChainId(&_ISystem.CallOpts, chainID) +} + +// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. +// +// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) +func (_ISystem *ISystemCallerSession) GasPriceByChainId(chainID *big.Int) (*big.Int, error) { + return _ISystem.Contract.GasPriceByChainId(&_ISystem.CallOpts, chainID) +} + +// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. +// +// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemCaller) GasZetaPoolByChainId(opts *bind.CallOpts, chainID *big.Int) (common.Address, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "gasZetaPoolByChainId", chainID) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. +// +// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemSession) GasZetaPoolByChainId(chainID *big.Int) (common.Address, error) { + return _ISystem.Contract.GasZetaPoolByChainId(&_ISystem.CallOpts, chainID) +} + +// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. +// +// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) +func (_ISystem *ISystemCallerSession) GasZetaPoolByChainId(chainID *big.Int) (common.Address, error) { + return _ISystem.Contract.GasZetaPoolByChainId(&_ISystem.CallOpts, chainID) +} + +// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. +// +// Solidity: function uniswapv2FactoryAddress() view returns(address) +func (_ISystem *ISystemCaller) Uniswapv2FactoryAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "uniswapv2FactoryAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. +// +// Solidity: function uniswapv2FactoryAddress() view returns(address) +func (_ISystem *ISystemSession) Uniswapv2FactoryAddress() (common.Address, error) { + return _ISystem.Contract.Uniswapv2FactoryAddress(&_ISystem.CallOpts) +} + +// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. +// +// Solidity: function uniswapv2FactoryAddress() view returns(address) +func (_ISystem *ISystemCallerSession) Uniswapv2FactoryAddress() (common.Address, error) { + return _ISystem.Contract.Uniswapv2FactoryAddress(&_ISystem.CallOpts) +} + +// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. +// +// Solidity: function wZetaContractAddress() view returns(address) +func (_ISystem *ISystemCaller) WZetaContractAddress(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ISystem.contract.Call(opts, &out, "wZetaContractAddress") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. +// +// Solidity: function wZetaContractAddress() view returns(address) +func (_ISystem *ISystemSession) WZetaContractAddress() (common.Address, error) { + return _ISystem.Contract.WZetaContractAddress(&_ISystem.CallOpts) +} + +// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. +// +// Solidity: function wZetaContractAddress() view returns(address) +func (_ISystem *ISystemCallerSession) WZetaContractAddress() (common.Address, error) { + return _ISystem.Contract.WZetaContractAddress(&_ISystem.CallOpts) +} diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go index c16e5efc..115677f6 100644 --- a/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go +++ b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20.go @@ -31,7 +31,7 @@ var ( // IZRC20MetaData contains all meta data concerning the IZRC20 contract. var IZRC20MetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + ABI: "[{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", } // IZRC20ABI is the input ABI used to generate the binding from. @@ -378,27 +378,6 @@ func (_IZRC20 *IZRC20TransactorSession) Burn(amount *big.Int) (*types.Transactio return _IZRC20.Contract.Burn(&_IZRC20.TransactOpts, amount) } -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "decreaseAllowance", spender, amount) -} - -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) DecreaseAllowance(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.DecreaseAllowance(&_IZRC20.TransactOpts, spender, amount) -} - -// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. -// -// Solidity: function decreaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) DecreaseAllowance(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.DecreaseAllowance(&_IZRC20.TransactOpts, spender, amount) -} - // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. // // Solidity: function deposit(address to, uint256 amount) returns(bool) @@ -420,27 +399,6 @@ func (_IZRC20 *IZRC20TransactorSession) Deposit(to common.Address, amount *big.I return _IZRC20.Contract.Deposit(&_IZRC20.TransactOpts, to, amount) } -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.contract.Transact(opts, "increaseAllowance", spender, amount) -} - -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20Session) IncreaseAllowance(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.IncreaseAllowance(&_IZRC20.TransactOpts, spender, amount) -} - -// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. -// -// Solidity: function increaseAllowance(address spender, uint256 amount) returns(bool) -func (_IZRC20 *IZRC20TransactorSession) IncreaseAllowance(spender common.Address, amount *big.Int) (*types.Transaction, error) { - return _IZRC20.Contract.IncreaseAllowance(&_IZRC20.TransactOpts, spender, amount) -} - // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. // // Solidity: function transfer(address recipient, uint256 amount) returns(bool) @@ -503,1007 +461,3 @@ func (_IZRC20 *IZRC20Session) Withdraw(to []byte, amount *big.Int) (*types.Trans func (_IZRC20 *IZRC20TransactorSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { return _IZRC20.Contract.Withdraw(&_IZRC20.TransactOpts, to, amount) } - -// IZRC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IZRC20 contract. -type IZRC20ApprovalIterator struct { - Event *IZRC20Approval // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20ApprovalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Approval) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20ApprovalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20ApprovalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Approval represents a Approval event raised by the IZRC20 contract. -type IZRC20Approval struct { - Owner common.Address - Spender common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IZRC20ApprovalIterator, 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 := _IZRC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) - if err != nil { - return nil, err - } - return &IZRC20ApprovalIterator{contract: _IZRC20.contract, event: "Approval", logs: logs, sub: sub}, nil -} - -// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IZRC20Approval, 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 := _IZRC20.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Approval) - if err := _IZRC20.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 -} - -// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. -// -// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseApproval(log types.Log) (*IZRC20Approval, error) { - event := new(IZRC20Approval) - if err := _IZRC20.contract.UnpackLog(event, "Approval", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20DepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the IZRC20 contract. -type IZRC20DepositIterator struct { - Event *IZRC20Deposit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20DepositIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Deposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Deposit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20DepositIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20DepositIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Deposit represents a Deposit event raised by the IZRC20 contract. -type IZRC20Deposit struct { - From []byte - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterDeposit is a free log retrieval operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterDeposit(opts *bind.FilterOpts, to []common.Address) (*IZRC20DepositIterator, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return &IZRC20DepositIterator{contract: _IZRC20.contract, event: "Deposit", logs: logs, sub: sub}, nil -} - -// WatchDeposit is a free log subscription operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *IZRC20Deposit, to []common.Address) (event.Subscription, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "Deposit", toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Deposit) - if err := _IZRC20.contract.UnpackLog(event, "Deposit", 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 -} - -// ParseDeposit is a log parse operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. -// -// Solidity: event Deposit(bytes from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseDeposit(log types.Log) (*IZRC20Deposit, error) { - event := new(IZRC20Deposit) - if err := _IZRC20.contract.UnpackLog(event, "Deposit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IZRC20 contract. -type IZRC20TransferIterator struct { - Event *IZRC20Transfer // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20TransferIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Transfer) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20TransferIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20TransferIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Transfer represents a Transfer event raised by the IZRC20 contract. -type IZRC20Transfer struct { - From common.Address - To common.Address - Value *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IZRC20TransferIterator, 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 := _IZRC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) - if err != nil { - return nil, err - } - return &IZRC20TransferIterator{contract: _IZRC20.contract, event: "Transfer", logs: logs, sub: sub}, nil -} - -// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IZRC20Transfer, 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 := _IZRC20.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: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Transfer) - if err := _IZRC20.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 -} - -// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. -// -// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) -func (_IZRC20 *IZRC20Filterer) ParseTransfer(log types.Log) (*IZRC20Transfer, error) { - event := new(IZRC20Transfer) - if err := _IZRC20.contract.UnpackLog(event, "Transfer", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedGasLimitIterator is returned from FilterUpdatedGasLimit and is used to iterate over the raw logs and unpacked data for UpdatedGasLimit events raised by the IZRC20 contract. -type IZRC20UpdatedGasLimitIterator struct { - Event *IZRC20UpdatedGasLimit // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedGasLimitIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedGasLimit) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedGasLimitIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedGasLimitIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedGasLimit represents a UpdatedGasLimit event raised by the IZRC20 contract. -type IZRC20UpdatedGasLimit struct { - GasLimit *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedGasLimit is a free log retrieval operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedGasLimit(opts *bind.FilterOpts) (*IZRC20UpdatedGasLimitIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return &IZRC20UpdatedGasLimitIterator{contract: _IZRC20.contract, event: "UpdatedGasLimit", logs: logs, sub: sub}, nil -} - -// WatchUpdatedGasLimit is a free log subscription operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedGasLimit(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedGasLimit) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedGasLimit") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedGasLimit) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedGasLimit", 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 -} - -// ParseUpdatedGasLimit is a log parse operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. -// -// Solidity: event UpdatedGasLimit(uint256 gasLimit) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedGasLimit(log types.Log) (*IZRC20UpdatedGasLimit, error) { - event := new(IZRC20UpdatedGasLimit) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedGasLimit", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedProtocolFlatFeeIterator is returned from FilterUpdatedProtocolFlatFee and is used to iterate over the raw logs and unpacked data for UpdatedProtocolFlatFee events raised by the IZRC20 contract. -type IZRC20UpdatedProtocolFlatFeeIterator struct { - Event *IZRC20UpdatedProtocolFlatFee // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedProtocolFlatFee) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedProtocolFlatFeeIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedProtocolFlatFee represents a UpdatedProtocolFlatFee event raised by the IZRC20 contract. -type IZRC20UpdatedProtocolFlatFee struct { - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedProtocolFlatFee is a free log retrieval operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedProtocolFlatFee(opts *bind.FilterOpts) (*IZRC20UpdatedProtocolFlatFeeIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return &IZRC20UpdatedProtocolFlatFeeIterator{contract: _IZRC20.contract, event: "UpdatedProtocolFlatFee", logs: logs, sub: sub}, nil -} - -// WatchUpdatedProtocolFlatFee is a free log subscription operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedProtocolFlatFee(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedProtocolFlatFee) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedProtocolFlatFee") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedProtocolFlatFee) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedProtocolFlatFee", 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 -} - -// ParseUpdatedProtocolFlatFee is a log parse operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. -// -// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedProtocolFlatFee(log types.Log) (*IZRC20UpdatedProtocolFlatFee, error) { - event := new(IZRC20UpdatedProtocolFlatFee) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedProtocolFlatFee", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20UpdatedSystemContractIterator is returned from FilterUpdatedSystemContract and is used to iterate over the raw logs and unpacked data for UpdatedSystemContract events raised by the IZRC20 contract. -type IZRC20UpdatedSystemContractIterator struct { - Event *IZRC20UpdatedSystemContract // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20UpdatedSystemContractIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20UpdatedSystemContract) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20UpdatedSystemContractIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20UpdatedSystemContractIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20UpdatedSystemContract represents a UpdatedSystemContract event raised by the IZRC20 contract. -type IZRC20UpdatedSystemContract struct { - SystemContract common.Address - Raw types.Log // Blockchain specific contextual infos -} - -// FilterUpdatedSystemContract is a free log retrieval operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) FilterUpdatedSystemContract(opts *bind.FilterOpts) (*IZRC20UpdatedSystemContractIterator, error) { - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return &IZRC20UpdatedSystemContractIterator{contract: _IZRC20.contract, event: "UpdatedSystemContract", logs: logs, sub: sub}, nil -} - -// WatchUpdatedSystemContract is a free log subscription operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) WatchUpdatedSystemContract(opts *bind.WatchOpts, sink chan<- *IZRC20UpdatedSystemContract) (event.Subscription, error) { - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "UpdatedSystemContract") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20UpdatedSystemContract) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedSystemContract", 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 -} - -// ParseUpdatedSystemContract is a log parse operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. -// -// Solidity: event UpdatedSystemContract(address systemContract) -func (_IZRC20 *IZRC20Filterer) ParseUpdatedSystemContract(log types.Log) (*IZRC20UpdatedSystemContract, error) { - event := new(IZRC20UpdatedSystemContract) - if err := _IZRC20.contract.UnpackLog(event, "UpdatedSystemContract", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// IZRC20WithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the IZRC20 contract. -type IZRC20WithdrawalIterator struct { - Event *IZRC20Withdrawal // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *IZRC20WithdrawalIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(IZRC20Withdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(IZRC20Withdrawal) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *IZRC20WithdrawalIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *IZRC20WithdrawalIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// IZRC20Withdrawal represents a Withdrawal event raised by the IZRC20 contract. -type IZRC20Withdrawal struct { - From common.Address - To []byte - Value *big.Int - GasFee *big.Int - ProtocolFlatFee *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*IZRC20WithdrawalIterator, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20.contract.FilterLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return &IZRC20WithdrawalIterator{contract: _IZRC20.contract, event: "Withdrawal", logs: logs, sub: sub}, nil -} - -// WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *IZRC20Withdrawal, from []common.Address) (event.Subscription, error) { - - var fromRule []interface{} - for _, fromItem := range from { - fromRule = append(fromRule, fromItem) - } - - logs, sub, err := _IZRC20.contract.WatchLogs(opts, "Withdrawal", fromRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(IZRC20Withdrawal) - if err := _IZRC20.contract.UnpackLog(event, "Withdrawal", 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 -} - -// ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. -// -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) -func (_IZRC20 *IZRC20Filterer) ParseWithdrawal(log types.Log) (*IZRC20Withdrawal, error) { - event := new(IZRC20Withdrawal) - if err := _IZRC20.contract.UnpackLog(event, "Withdrawal", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20metadata.go b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20metadata.go new file mode 100644 index 00000000..d60ed6ff --- /dev/null +++ b/pkg/contracts/zevm/interfaces/izrc20.sol/izrc20metadata.go @@ -0,0 +1,556 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package izrc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IZRC20MetadataMetaData contains all meta data concerning the IZRC20Metadata contract. +var IZRC20MetadataMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// IZRC20MetadataABI is the input ABI used to generate the binding from. +// Deprecated: Use IZRC20MetadataMetaData.ABI instead. +var IZRC20MetadataABI = IZRC20MetadataMetaData.ABI + +// IZRC20Metadata is an auto generated Go binding around an Ethereum contract. +type IZRC20Metadata struct { + IZRC20MetadataCaller // Read-only binding to the contract + IZRC20MetadataTransactor // Write-only binding to the contract + IZRC20MetadataFilterer // Log filterer for contract events +} + +// IZRC20MetadataCaller is an auto generated read-only Go binding around an Ethereum contract. +type IZRC20MetadataCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZRC20MetadataTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IZRC20MetadataTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZRC20MetadataFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IZRC20MetadataFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZRC20MetadataSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IZRC20MetadataSession struct { + Contract *IZRC20Metadata // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IZRC20MetadataCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IZRC20MetadataCallerSession struct { + Contract *IZRC20MetadataCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IZRC20MetadataTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IZRC20MetadataTransactorSession struct { + Contract *IZRC20MetadataTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IZRC20MetadataRaw is an auto generated low-level Go binding around an Ethereum contract. +type IZRC20MetadataRaw struct { + Contract *IZRC20Metadata // Generic contract binding to access the raw methods on +} + +// IZRC20MetadataCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IZRC20MetadataCallerRaw struct { + Contract *IZRC20MetadataCaller // Generic read-only contract binding to access the raw methods on +} + +// IZRC20MetadataTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IZRC20MetadataTransactorRaw struct { + Contract *IZRC20MetadataTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIZRC20Metadata creates a new instance of IZRC20Metadata, bound to a specific deployed contract. +func NewIZRC20Metadata(address common.Address, backend bind.ContractBackend) (*IZRC20Metadata, error) { + contract, err := bindIZRC20Metadata(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IZRC20Metadata{IZRC20MetadataCaller: IZRC20MetadataCaller{contract: contract}, IZRC20MetadataTransactor: IZRC20MetadataTransactor{contract: contract}, IZRC20MetadataFilterer: IZRC20MetadataFilterer{contract: contract}}, nil +} + +// NewIZRC20MetadataCaller creates a new read-only instance of IZRC20Metadata, bound to a specific deployed contract. +func NewIZRC20MetadataCaller(address common.Address, caller bind.ContractCaller) (*IZRC20MetadataCaller, error) { + contract, err := bindIZRC20Metadata(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IZRC20MetadataCaller{contract: contract}, nil +} + +// NewIZRC20MetadataTransactor creates a new write-only instance of IZRC20Metadata, bound to a specific deployed contract. +func NewIZRC20MetadataTransactor(address common.Address, transactor bind.ContractTransactor) (*IZRC20MetadataTransactor, error) { + contract, err := bindIZRC20Metadata(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IZRC20MetadataTransactor{contract: contract}, nil +} + +// NewIZRC20MetadataFilterer creates a new log filterer instance of IZRC20Metadata, bound to a specific deployed contract. +func NewIZRC20MetadataFilterer(address common.Address, filterer bind.ContractFilterer) (*IZRC20MetadataFilterer, error) { + contract, err := bindIZRC20Metadata(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IZRC20MetadataFilterer{contract: contract}, nil +} + +// bindIZRC20Metadata binds a generic wrapper to an already deployed contract. +func bindIZRC20Metadata(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IZRC20MetadataMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IZRC20Metadata *IZRC20MetadataRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IZRC20Metadata.Contract.IZRC20MetadataCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IZRC20Metadata *IZRC20MetadataRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.IZRC20MetadataTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IZRC20Metadata *IZRC20MetadataRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.IZRC20MetadataTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IZRC20Metadata *IZRC20MetadataCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IZRC20Metadata.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IZRC20Metadata *IZRC20MetadataTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IZRC20Metadata *IZRC20MetadataTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.contract.Transact(opts, method, params...) +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCaller) PROTOCOLFLATFEE(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IZRC20Metadata.contract.Call(opts, &out, "PROTOCOL_FLAT_FEE") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataSession) PROTOCOLFLATFEE() (*big.Int, error) { + return _IZRC20Metadata.Contract.PROTOCOLFLATFEE(&_IZRC20Metadata.CallOpts) +} + +// PROTOCOLFLATFEE is a free data retrieval call binding the contract method 0x4d8943bb. +// +// Solidity: function PROTOCOL_FLAT_FEE() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) PROTOCOLFLATFEE() (*big.Int, error) { + return _IZRC20Metadata.Contract.PROTOCOLFLATFEE(&_IZRC20Metadata.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _IZRC20Metadata.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IZRC20Metadata.Contract.Allowance(&_IZRC20Metadata.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IZRC20Metadata.Contract.Allowance(&_IZRC20Metadata.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _IZRC20Metadata.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 + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IZRC20Metadata.Contract.BalanceOf(&_IZRC20Metadata.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IZRC20Metadata.Contract.BalanceOf(&_IZRC20Metadata.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IZRC20Metadata *IZRC20MetadataCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _IZRC20Metadata.contract.Call(opts, &out, "decimals") + + if err != nil { + return *new(uint8), err + } + + out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8) + + return out0, err + +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IZRC20Metadata *IZRC20MetadataSession) Decimals() (uint8, error) { + return _IZRC20Metadata.Contract.Decimals(&_IZRC20Metadata.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) Decimals() (uint8, error) { + return _IZRC20Metadata.Contract.Decimals(&_IZRC20Metadata.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IZRC20Metadata.contract.Call(opts, &out, "name") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataSession) Name() (string, error) { + return _IZRC20Metadata.Contract.Name(&_IZRC20Metadata.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) Name() (string, error) { + return _IZRC20Metadata.Contract.Name(&_IZRC20Metadata.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _IZRC20Metadata.contract.Call(opts, &out, "symbol") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataSession) Symbol() (string, error) { + return _IZRC20Metadata.Contract.Symbol(&_IZRC20Metadata.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) Symbol() (string, error) { + return _IZRC20Metadata.Contract.Symbol(&_IZRC20Metadata.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IZRC20Metadata.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataSession) TotalSupply() (*big.Int, error) { + return _IZRC20Metadata.Contract.TotalSupply(&_IZRC20Metadata.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) TotalSupply() (*big.Int, error) { + return _IZRC20Metadata.Contract.TotalSupply(&_IZRC20Metadata.CallOpts) +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_IZRC20Metadata *IZRC20MetadataCaller) WithdrawGasFee(opts *bind.CallOpts) (common.Address, *big.Int, error) { + var out []interface{} + err := _IZRC20Metadata.contract.Call(opts, &out, "withdrawGasFee") + + if err != nil { + return *new(common.Address), *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + out1 := *abi.ConvertType(out[1], new(*big.Int)).(**big.Int) + + return out0, out1, err + +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_IZRC20Metadata *IZRC20MetadataSession) WithdrawGasFee() (common.Address, *big.Int, error) { + return _IZRC20Metadata.Contract.WithdrawGasFee(&_IZRC20Metadata.CallOpts) +} + +// WithdrawGasFee is a free data retrieval call binding the contract method 0xd9eeebed. +// +// Solidity: function withdrawGasFee() view returns(address, uint256) +func (_IZRC20Metadata *IZRC20MetadataCallerSession) WithdrawGasFee() (common.Address, *big.Int, error) { + return _IZRC20Metadata.Contract.WithdrawGasFee(&_IZRC20Metadata.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Approve(&_IZRC20Metadata.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Approve(&_IZRC20Metadata.TransactOpts, spender, amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "burn", amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Burn(&_IZRC20Metadata.TransactOpts, amount) +} + +// Burn is a paid mutator transaction binding the contract method 0x42966c68. +// +// Solidity: function burn(uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Burn(&_IZRC20Metadata.TransactOpts, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) Deposit(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "deposit", to, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Deposit(&_IZRC20Metadata.TransactOpts, to, amount) +} + +// Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. +// +// Solidity: function deposit(address to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Deposit(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Deposit(&_IZRC20Metadata.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "transfer", recipient, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Transfer(&_IZRC20Metadata.TransactOpts, recipient, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Transfer(&_IZRC20Metadata.TransactOpts, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "transferFrom", sender, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.TransferFrom(&_IZRC20Metadata.TransactOpts, sender, recipient, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.TransferFrom(&_IZRC20Metadata.TransactOpts, sender, recipient, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactor) Withdraw(opts *bind.TransactOpts, to []byte, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.contract.Transact(opts, "withdraw", to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Withdraw(&_IZRC20Metadata.TransactOpts, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xc7012626. +// +// Solidity: function withdraw(bytes to, uint256 amount) returns(bool) +func (_IZRC20Metadata *IZRC20MetadataTransactorSession) Withdraw(to []byte, amount *big.Int) (*types.Transaction, error) { + return _IZRC20Metadata.Contract.Withdraw(&_IZRC20Metadata.TransactOpts, to, amount) +} diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/zrc20events.go b/pkg/contracts/zevm/interfaces/izrc20.sol/zrc20events.go new file mode 100644 index 00000000..3e3efb41 --- /dev/null +++ b/pkg/contracts/zevm/interfaces/izrc20.sol/zrc20events.go @@ -0,0 +1,1185 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package izrc20 + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZRC20EventsMetaData contains all meta data concerning the ZRC20Events contract. +var ZRC20EventsMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"}]", +} + +// ZRC20EventsABI is the input ABI used to generate the binding from. +// Deprecated: Use ZRC20EventsMetaData.ABI instead. +var ZRC20EventsABI = ZRC20EventsMetaData.ABI + +// ZRC20Events is an auto generated Go binding around an Ethereum contract. +type ZRC20Events struct { + ZRC20EventsCaller // Read-only binding to the contract + ZRC20EventsTransactor // Write-only binding to the contract + ZRC20EventsFilterer // Log filterer for contract events +} + +// ZRC20EventsCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZRC20EventsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20EventsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZRC20EventsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20EventsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZRC20EventsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZRC20EventsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZRC20EventsSession struct { + Contract *ZRC20Events // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20EventsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZRC20EventsCallerSession struct { + Contract *ZRC20EventsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZRC20EventsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZRC20EventsTransactorSession struct { + Contract *ZRC20EventsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZRC20EventsRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZRC20EventsRaw struct { + Contract *ZRC20Events // Generic contract binding to access the raw methods on +} + +// ZRC20EventsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZRC20EventsCallerRaw struct { + Contract *ZRC20EventsCaller // Generic read-only contract binding to access the raw methods on +} + +// ZRC20EventsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZRC20EventsTransactorRaw struct { + Contract *ZRC20EventsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZRC20Events creates a new instance of ZRC20Events, bound to a specific deployed contract. +func NewZRC20Events(address common.Address, backend bind.ContractBackend) (*ZRC20Events, error) { + contract, err := bindZRC20Events(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZRC20Events{ZRC20EventsCaller: ZRC20EventsCaller{contract: contract}, ZRC20EventsTransactor: ZRC20EventsTransactor{contract: contract}, ZRC20EventsFilterer: ZRC20EventsFilterer{contract: contract}}, nil +} + +// NewZRC20EventsCaller creates a new read-only instance of ZRC20Events, bound to a specific deployed contract. +func NewZRC20EventsCaller(address common.Address, caller bind.ContractCaller) (*ZRC20EventsCaller, error) { + contract, err := bindZRC20Events(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZRC20EventsCaller{contract: contract}, nil +} + +// NewZRC20EventsTransactor creates a new write-only instance of ZRC20Events, bound to a specific deployed contract. +func NewZRC20EventsTransactor(address common.Address, transactor bind.ContractTransactor) (*ZRC20EventsTransactor, error) { + contract, err := bindZRC20Events(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZRC20EventsTransactor{contract: contract}, nil +} + +// NewZRC20EventsFilterer creates a new log filterer instance of ZRC20Events, bound to a specific deployed contract. +func NewZRC20EventsFilterer(address common.Address, filterer bind.ContractFilterer) (*ZRC20EventsFilterer, error) { + contract, err := bindZRC20Events(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZRC20EventsFilterer{contract: contract}, nil +} + +// bindZRC20Events binds a generic wrapper to an already deployed contract. +func bindZRC20Events(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZRC20EventsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20Events *ZRC20EventsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20Events.Contract.ZRC20EventsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20Events *ZRC20EventsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20Events.Contract.ZRC20EventsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20Events *ZRC20EventsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20Events.Contract.ZRC20EventsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZRC20Events *ZRC20EventsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZRC20Events.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZRC20Events *ZRC20EventsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZRC20Events.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZRC20Events *ZRC20EventsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZRC20Events.Contract.contract.Transact(opts, method, params...) +} + +// ZRC20EventsApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ZRC20Events contract. +type ZRC20EventsApprovalIterator struct { + Event *ZRC20EventsApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsApproval represents a Approval event raised by the ZRC20Events contract. +type ZRC20EventsApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ZRC20EventsApprovalIterator, 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 := _ZRC20Events.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &ZRC20EventsApprovalIterator{contract: _ZRC20Events.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ZRC20EventsApproval, 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 := _ZRC20Events.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: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsApproval) + if err := _ZRC20Events.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) ParseApproval(log types.Log) (*ZRC20EventsApproval, error) { + event := new(ZRC20EventsApproval) + if err := _ZRC20Events.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the ZRC20Events contract. +type ZRC20EventsDepositIterator struct { + Event *ZRC20EventsDeposit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsDepositIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsDeposit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsDepositIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsDepositIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsDeposit represents a Deposit event raised by the ZRC20Events contract. +type ZRC20EventsDeposit struct { + From []byte + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeposit is a free log retrieval operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) FilterDeposit(opts *bind.FilterOpts, to []common.Address) (*ZRC20EventsDepositIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZRC20Events.contract.FilterLogs(opts, "Deposit", toRule) + if err != nil { + return nil, err + } + return &ZRC20EventsDepositIterator{contract: _ZRC20Events.contract, event: "Deposit", logs: logs, sub: sub}, nil +} + +// WatchDeposit is a free log subscription operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *ZRC20EventsDeposit, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZRC20Events.contract.WatchLogs(opts, "Deposit", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsDeposit) + if err := _ZRC20Events.contract.UnpackLog(event, "Deposit", 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 +} + +// ParseDeposit is a log parse operation binding the contract event 0x67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab3. +// +// Solidity: event Deposit(bytes from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) ParseDeposit(log types.Log) (*ZRC20EventsDeposit, error) { + event := new(ZRC20EventsDeposit) + if err := _ZRC20Events.contract.UnpackLog(event, "Deposit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ZRC20Events contract. +type ZRC20EventsTransferIterator struct { + Event *ZRC20EventsTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsTransfer represents a Transfer event raised by the ZRC20Events contract. +type ZRC20EventsTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ZRC20EventsTransferIterator, 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 := _ZRC20Events.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ZRC20EventsTransferIterator{contract: _ZRC20Events.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ZRC20EventsTransfer, 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 := _ZRC20Events.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: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsTransfer) + if err := _ZRC20Events.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ZRC20Events *ZRC20EventsFilterer) ParseTransfer(log types.Log) (*ZRC20EventsTransfer, error) { + event := new(ZRC20EventsTransfer) + if err := _ZRC20Events.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsUpdatedGasLimitIterator is returned from FilterUpdatedGasLimit and is used to iterate over the raw logs and unpacked data for UpdatedGasLimit events raised by the ZRC20Events contract. +type ZRC20EventsUpdatedGasLimitIterator struct { + Event *ZRC20EventsUpdatedGasLimit // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsUpdatedGasLimitIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedGasLimit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedGasLimit) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsUpdatedGasLimitIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsUpdatedGasLimitIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsUpdatedGasLimit represents a UpdatedGasLimit event raised by the ZRC20Events contract. +type ZRC20EventsUpdatedGasLimit struct { + GasLimit *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedGasLimit is a free log retrieval operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20Events *ZRC20EventsFilterer) FilterUpdatedGasLimit(opts *bind.FilterOpts) (*ZRC20EventsUpdatedGasLimitIterator, error) { + + logs, sub, err := _ZRC20Events.contract.FilterLogs(opts, "UpdatedGasLimit") + if err != nil { + return nil, err + } + return &ZRC20EventsUpdatedGasLimitIterator{contract: _ZRC20Events.contract, event: "UpdatedGasLimit", logs: logs, sub: sub}, nil +} + +// WatchUpdatedGasLimit is a free log subscription operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20Events *ZRC20EventsFilterer) WatchUpdatedGasLimit(opts *bind.WatchOpts, sink chan<- *ZRC20EventsUpdatedGasLimit) (event.Subscription, error) { + + logs, sub, err := _ZRC20Events.contract.WatchLogs(opts, "UpdatedGasLimit") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsUpdatedGasLimit) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedGasLimit", 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 +} + +// ParseUpdatedGasLimit is a log parse operation binding the contract event 0xff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a. +// +// Solidity: event UpdatedGasLimit(uint256 gasLimit) +func (_ZRC20Events *ZRC20EventsFilterer) ParseUpdatedGasLimit(log types.Log) (*ZRC20EventsUpdatedGasLimit, error) { + event := new(ZRC20EventsUpdatedGasLimit) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedGasLimit", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsUpdatedProtocolFlatFeeIterator is returned from FilterUpdatedProtocolFlatFee and is used to iterate over the raw logs and unpacked data for UpdatedProtocolFlatFee events raised by the ZRC20Events contract. +type ZRC20EventsUpdatedProtocolFlatFeeIterator struct { + Event *ZRC20EventsUpdatedProtocolFlatFee // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsUpdatedProtocolFlatFeeIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedProtocolFlatFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedProtocolFlatFee) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsUpdatedProtocolFlatFeeIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsUpdatedProtocolFlatFeeIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsUpdatedProtocolFlatFee represents a UpdatedProtocolFlatFee event raised by the ZRC20Events contract. +type ZRC20EventsUpdatedProtocolFlatFee struct { + ProtocolFlatFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedProtocolFlatFee is a free log retrieval operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) FilterUpdatedProtocolFlatFee(opts *bind.FilterOpts) (*ZRC20EventsUpdatedProtocolFlatFeeIterator, error) { + + logs, sub, err := _ZRC20Events.contract.FilterLogs(opts, "UpdatedProtocolFlatFee") + if err != nil { + return nil, err + } + return &ZRC20EventsUpdatedProtocolFlatFeeIterator{contract: _ZRC20Events.contract, event: "UpdatedProtocolFlatFee", logs: logs, sub: sub}, nil +} + +// WatchUpdatedProtocolFlatFee is a free log subscription operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) WatchUpdatedProtocolFlatFee(opts *bind.WatchOpts, sink chan<- *ZRC20EventsUpdatedProtocolFlatFee) (event.Subscription, error) { + + logs, sub, err := _ZRC20Events.contract.WatchLogs(opts, "UpdatedProtocolFlatFee") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsUpdatedProtocolFlatFee) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedProtocolFlatFee", 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 +} + +// ParseUpdatedProtocolFlatFee is a log parse operation binding the contract event 0xef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f. +// +// Solidity: event UpdatedProtocolFlatFee(uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) ParseUpdatedProtocolFlatFee(log types.Log) (*ZRC20EventsUpdatedProtocolFlatFee, error) { + event := new(ZRC20EventsUpdatedProtocolFlatFee) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedProtocolFlatFee", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsUpdatedSystemContractIterator is returned from FilterUpdatedSystemContract and is used to iterate over the raw logs and unpacked data for UpdatedSystemContract events raised by the ZRC20Events contract. +type ZRC20EventsUpdatedSystemContractIterator struct { + Event *ZRC20EventsUpdatedSystemContract // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsUpdatedSystemContractIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedSystemContract) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsUpdatedSystemContract) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsUpdatedSystemContractIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsUpdatedSystemContractIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsUpdatedSystemContract represents a UpdatedSystemContract event raised by the ZRC20Events contract. +type ZRC20EventsUpdatedSystemContract struct { + SystemContract common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUpdatedSystemContract is a free log retrieval operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20Events *ZRC20EventsFilterer) FilterUpdatedSystemContract(opts *bind.FilterOpts) (*ZRC20EventsUpdatedSystemContractIterator, error) { + + logs, sub, err := _ZRC20Events.contract.FilterLogs(opts, "UpdatedSystemContract") + if err != nil { + return nil, err + } + return &ZRC20EventsUpdatedSystemContractIterator{contract: _ZRC20Events.contract, event: "UpdatedSystemContract", logs: logs, sub: sub}, nil +} + +// WatchUpdatedSystemContract is a free log subscription operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20Events *ZRC20EventsFilterer) WatchUpdatedSystemContract(opts *bind.WatchOpts, sink chan<- *ZRC20EventsUpdatedSystemContract) (event.Subscription, error) { + + logs, sub, err := _ZRC20Events.contract.WatchLogs(opts, "UpdatedSystemContract") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsUpdatedSystemContract) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedSystemContract", 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 +} + +// ParseUpdatedSystemContract is a log parse operation binding the contract event 0xd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae. +// +// Solidity: event UpdatedSystemContract(address systemContract) +func (_ZRC20Events *ZRC20EventsFilterer) ParseUpdatedSystemContract(log types.Log) (*ZRC20EventsUpdatedSystemContract, error) { + event := new(ZRC20EventsUpdatedSystemContract) + if err := _ZRC20Events.contract.UnpackLog(event, "UpdatedSystemContract", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZRC20EventsWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the ZRC20Events contract. +type ZRC20EventsWithdrawalIterator struct { + Event *ZRC20EventsWithdrawal // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZRC20EventsWithdrawalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZRC20EventsWithdrawal) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZRC20EventsWithdrawalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZRC20EventsWithdrawalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZRC20EventsWithdrawal represents a Withdrawal event raised by the ZRC20Events contract. +type ZRC20EventsWithdrawal struct { + From common.Address + To []byte + Value *big.Int + GasFee *big.Int + ProtocolFlatFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*ZRC20EventsWithdrawalIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _ZRC20Events.contract.FilterLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return &ZRC20EventsWithdrawalIterator{contract: _ZRC20Events.contract, event: "Withdrawal", logs: logs, sub: sub}, nil +} + +// WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ZRC20EventsWithdrawal, from []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + + logs, sub, err := _ZRC20Events.contract.WatchLogs(opts, "Withdrawal", fromRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZRC20EventsWithdrawal) + if err := _ZRC20Events.contract.UnpackLog(event, "Withdrawal", 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 +} + +// ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. +// +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) +func (_ZRC20Events *ZRC20EventsFilterer) ParseWithdrawal(log types.Log) (*ZRC20EventsWithdrawal, error) { + event := new(ZRC20EventsWithdrawal) + if err := _ZRC20Events.contract.UnpackLog(event, "Withdrawal", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go index cc61517b..7b1cfa11 100644 --- a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go +++ b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go @@ -39,7 +39,7 @@ type ZContext struct { // SystemContractMetaData contains all meta data concerning the SystemContract contract. var SystemContractMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetConnectorZEVM\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setConnectorZEVMAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"erc20\",\"type\":\"address\"}],\"name\":\"setGasZetaPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnectorZEVMAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "0x60c06040523480156200001157600080fd5b50604051620018aa380380620018aa8339818101604052810190620000379190620001ac565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614620000b1576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b82600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b815250507f80699e81136d69cb8367ad52a994e25c722a86da654b561d0c14b61a777e7ac560405160405180910390a15050506200025b565b600081519050620001a68162000241565b92915050565b600080600060608486031215620001c857620001c76200023c565b5b6000620001d88682870162000195565b9350506020620001eb8682870162000195565b9250506040620001fe8682870162000195565b9150509250925092565b600062000215826200021c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200024c8162000208565b81146200025857600080fd5b50565b60805160601c60a05160601c61161c6200028e600039600061051b0152600081816105bd0152610bc5015261161c6000f3fe608060405234801561001057600080fd5b50600436106100f55760003560e01c806397770dff11610097578063c63585cc11610066578063c63585cc1461025e578063d7fd7afb1461028e578063d936a012146102be578063ee2815ba146102dc576100f5565b806397770dff146101ec578063a7cb050714610208578063c39aca3714610224578063c62178ac14610240576100f5565b8063513a9c05116100d3578063513a9c0514610164578063569541b914610194578063842da36d146101b257806391dd645f146101d0576100f5565b80630be15547146100fa5780631f0e251b1461012a5780633ce4a5bc14610146575b600080fd5b610114600480360381019061010f9190611022565b6102f8565b60405161012191906112b1565b60405180910390f35b610144600480360381019061013f9190610ebf565b61032b565b005b61014e6104a8565b60405161015b91906112b1565b60405180910390f35b61017e60048036038101906101799190611022565b6104c0565b60405161018b91906112b1565b60405180910390f35b61019c6104f3565b6040516101a991906112b1565b60405180910390f35b6101ba610519565b6040516101c791906112b1565b60405180910390f35b6101ea60048036038101906101e5919061104f565b61053d565b005b61020660048036038101906102019190610ebf565b610697565b005b610222600480360381019061021d919061108f565b610814565b005b61023e60048036038101906102399190610f6c565b6108e1565b005b610248610b13565b60405161025591906112b1565b60405180910390f35b61027860048036038101906102739190610eec565b610b39565b60405161028591906112b1565b60405180910390f35b6102a860048036038101906102a39190611022565b610bab565b6040516102b5919061134a565b60405180910390f35b6102c6610bc3565b6040516102d391906112b1565b60405180910390f35b6102f660048036038101906102f1919061104f565b610be7565b005b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146103a4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561040b576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f3ade88e3922d64780e1bf4460d364c2970b69da813f9c0c07a1c187b5647636c600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405161049d91906112b1565b60405180910390a150565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b60026020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b7f000000000000000000000000000000000000000000000000000000000000000081565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146105b6576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60006106057f0000000000000000000000000000000000000000000000000000000000000000600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684610b39565b9050806002600085815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f0ecec485166da6139b13bb7e033e9446e2d35348e80ebf1180d4afe2dba1704e838260405161068a929190611365565b60405180910390a1505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610710576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610777576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fdba79d534382d1a8ae108e4c8ecb27c6ae42ab8b91d44eedf88bd329f3868d5e600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405161080991906112b1565b60405180910390a150565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461088d576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600080848152602001908152602001600020819055507f49f492222906ac486c3c1401fa545626df1f0c0e5a77a05597ea2ed66af9850d82826040516108d592919061138e565b60405180910390a15050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461095a576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614806109d357503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610a0a576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610a459291906112cc565b602060405180830381600087803b158015610a5f57600080fd5b505af1158015610a73573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a979190610f3f565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610ad99594939291906112f5565b600060405180830381600087803b158015610af357600080fd5b505af1158015610b07573d6000803e3d6000fd5b50505050505050505050565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000806000610b488585610cef565b91509150858282604051602001610b60929190611243565b60405160208183030381529060405280519060200120604051602001610b8792919061126f565b6040516020818303038152906040528051906020012060001c925050509392505050565b60006020528060005260406000206000915090505481565b7f000000000000000000000000000000000000000000000000000000000000000081565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610c60576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806001600084815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd1b36d30f6248e97c473b4d1348ca164a4ef6759022f54a58ec200326c39c45d8282604051610ce3929190611365565b60405180910390a15050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161415610d58576040517fcb1e7cfe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1610610d92578284610d95565b83835b8092508193505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610e04576040517f78b507da00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b9250929050565b600081359050610e1a816115a1565b92915050565b600081519050610e2f816115b8565b92915050565b60008083601f840112610e4b57610e4a61150e565b5b8235905067ffffffffffffffff811115610e6857610e67611509565b5b602083019150836001820283011115610e8457610e8361151d565b5b9250929050565b600060608284031215610ea157610ea0611513565b5b81905092915050565b600081359050610eb9816115cf565b92915050565b600060208284031215610ed557610ed461152c565b5b6000610ee384828501610e0b565b91505092915050565b600080600060608486031215610f0557610f0461152c565b5b6000610f1386828701610e0b565b9350506020610f2486828701610e0b565b9250506040610f3586828701610e0b565b9150509250925092565b600060208284031215610f5557610f5461152c565b5b6000610f6384828501610e20565b91505092915050565b60008060008060008060a08789031215610f8957610f8861152c565b5b600087013567ffffffffffffffff811115610fa757610fa6611522565b5b610fb389828a01610e8b565b9650506020610fc489828a01610e0b565b9550506040610fd589828a01610eaa565b9450506060610fe689828a01610e0b565b935050608087013567ffffffffffffffff81111561100757611006611522565b5b61101389828a01610e35565b92509250509295509295509295565b6000602082840312156110385761103761152c565b5b600061104684828501610eaa565b91505092915050565b600080604083850312156110665761106561152c565b5b600061107485828601610eaa565b925050602061108585828601610e0b565b9150509250929050565b600080604083850312156110a6576110a561152c565b5b60006110b485828601610eaa565b92505060206110c585828601610eaa565b9150509250929050565b6110d881611475565b82525050565b6110e781611475565b82525050565b6110fe6110f982611475565b6114d6565b82525050565b61111561111082611493565b6114e8565b82525050565b600061112783856113b7565b93506111348385846114c7565b61113d83611531565b840190509392505050565b600061115483856113c8565b93506111618385846114c7565b61116a83611531565b840190509392505050565b60006111826020836113d9565b915061118d8261154f565b602082019050919050565b60006111a56001836113d9565b91506111b082611578565b600182019050919050565b6000606083016111ce60008401846113fb565b85830360008701526111e183828461111b565b925050506111f260208401846113e4565b6111ff60208601826110cf565b5061120d604084018461145e565b61121a6040860182611225565b508091505092915050565b61122e816114bd565b82525050565b61123d816114bd565b82525050565b600061124f82856110ed565b60148201915061125f82846110ed565b6014820191508190509392505050565b600061127a82611198565b915061128682856110ed565b6014820191506112968284611104565b6020820191506112a582611175565b91508190509392505050565b60006020820190506112c660008301846110de565b92915050565b60006040820190506112e160008301856110de565b6112ee6020830184611234565b9392505050565b6000608082019050818103600083015261130f81886111bb565b905061131e60208301876110de565b61132b6040830186611234565b818103606083015261133e818486611148565b90509695505050505050565b600060208201905061135f6000830184611234565b92915050565b600060408201905061137a6000830185611234565b61138760208301846110de565b9392505050565b60006040820190506113a36000830185611234565b6113b06020830184611234565b9392505050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b60006113f36020840184610e0b565b905092915050565b6000808335600160200384360303811261141857611417611527565b5b83810192508235915060208301925067ffffffffffffffff8211156114405761143f611504565b5b60018202360384131561145657611455611518565b5b509250929050565b600061146d6020840184610eaa565b905092915050565b60006114808261149d565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60006114e1826114f2565b9050919050565b6000819050919050565b60006114fd82611542565b9050919050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f600082015250565b7fff00000000000000000000000000000000000000000000000000000000000000600082015250565b6115aa81611475565b81146115b557600080fd5b50565b6115c181611487565b81146115cc57600080fd5b50565b6115d8816114bd565b81146115e357600080fd5b5056fea26469706673582212207875ed7b29614b36fed6df17ab4d8319246cc854565244214ea9e3ec60e5598264736f6c63430008070033", + Bin: "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", } // SystemContractABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go index 0eef1d99..c6537874 100644 --- a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go +++ b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go @@ -32,7 +32,7 @@ var ( // SystemContractMockMetaData contains all meta data concerning the SystemContractMock contract. var SystemContractMockMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"onCrossChainCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "0x60806040523480156200001157600080fd5b50604051620010d7380380620010d7833981810160405281019062000037919062000146565b82600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f80699e81136d69cb8367ad52a994e25c722a86da654b561d0c14b61a777e7ac560405160405180910390a1505050620001f5565b6000815190506200014081620001db565b92915050565b600080600060608486031215620001625762000161620001d6565b5b600062000172868287016200012f565b935050602062000185868287016200012f565b925050604062000198868287016200012f565b9150509250925092565b6000620001af82620001b6565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b620001e681620001a2565b8114620001f257600080fd5b50565b610ed280620002056000396000f3fe608060405234801561001057600080fd5b50600436106100a95760003560e01c806397770dff1161007157806397770dff14610166578063a7cb050714610182578063c63585cc1461019e578063d7fd7afb146101ce578063d936a012146101fe578063ee2815ba1461021c576100a9565b80630be15547146100ae5780633c669d55146100de578063513a9c05146100fa578063569541b91461012a578063842da36d14610148575b600080fd5b6100c860048036038101906100c3919061094d565b610238565b6040516100d59190610bce565b60405180910390f35b6100f860048036038101906100f39190610898565b61026b565b005b610114600480360381019061010f919061094d565b6103b8565b6040516101219190610bce565b60405180910390f35b6101326103eb565b60405161013f9190610bce565b60405180910390f35b610150610411565b60405161015d9190610bce565b60405180910390f35b610180600480360381019061017b9190610818565b610437565b005b61019c600480360381019061019791906109ba565b6104d4565b005b6101b860048036038101906101b39190610845565b610528565b6040516101c59190610bce565b60405180910390f35b6101e860048036038101906101e3919061094d565b61059a565b6040516101f59190610c67565b60405180910390f35b6102066105b2565b6040516102139190610bce565b60405180910390f35b6102366004803603810190610231919061097a565b6105d8565b005b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600060405180606001604052806040518060200160405280600081525081526020013373ffffffffffffffffffffffffffffffffffffffff1681526020014681525090508473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb87866040518363ffffffff1660e01b81526004016102ea929190610be9565b602060405180830381600087803b15801561030457600080fd5b505af1158015610318573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061033c9190610920565b508573ffffffffffffffffffffffffffffffffffffffff1663de43156e82878787876040518663ffffffff1660e01b815260040161037e959493929190610c12565b600060405180830381600087803b15801561039857600080fd5b505af11580156103ac573d6000803e3d6000fd5b50505050505050505050565b60026020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fdba79d534382d1a8ae108e4c8ecb27c6ae42ab8b91d44eedf88bd329f3868d5e600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516104c99190610bce565b60405180910390a150565b80600080848152602001908152602001600020819055507f49f492222906ac486c3c1401fa545626df1f0c0e5a77a05597ea2ed66af9850d828260405161051c929190610cab565b60405180910390a15050565b60008060006105378585610667565b9150915085828260405160200161054f929190610b60565b60405160208183030381529060405280519060200120604051602001610576929190610b8c565b6040516020818303038152906040528051906020012060001c925050509392505050565b60006020528060005260406000206000915090505481565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b806001600084815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd1b36d30f6248e97c473b4d1348ca164a4ef6759022f54a58ec200326c39c45d828260405161065b929190610c82565b60405180910390a15050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156106d0576040517fcb1e7cfe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161061070a57828461070d565b83835b8092508193505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561077c576040517f78b507da00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b9250929050565b60008135905061079281610e57565b92915050565b6000815190506107a781610e6e565b92915050565b60008083601f8401126107c3576107c2610dd3565b5b8235905067ffffffffffffffff8111156107e0576107df610dce565b5b6020830191508360018202830111156107fc576107fb610dd8565b5b9250929050565b60008135905061081281610e85565b92915050565b60006020828403121561082e5761082d610de2565b5b600061083c84828501610783565b91505092915050565b60008060006060848603121561085e5761085d610de2565b5b600061086c86828701610783565b935050602061087d86828701610783565b925050604061088e86828701610783565b9150509250925092565b6000806000806000608086880312156108b4576108b3610de2565b5b60006108c288828901610783565b95505060206108d388828901610783565b94505060406108e488828901610803565b935050606086013567ffffffffffffffff81111561090557610904610ddd565b5b610911888289016107ad565b92509250509295509295909350565b60006020828403121561093657610935610de2565b5b600061094484828501610798565b91505092915050565b60006020828403121561096357610962610de2565b5b600061097184828501610803565b91505092915050565b6000806040838503121561099157610990610de2565b5b600061099f85828601610803565b92505060206109b085828601610783565b9150509250929050565b600080604083850312156109d1576109d0610de2565b5b60006109df85828601610803565b92505060206109f085828601610803565b9150509250929050565b610a0381610d0c565b82525050565b610a1281610d0c565b82525050565b610a29610a2482610d0c565b610da0565b82525050565b610a40610a3b82610d2a565b610db2565b82525050565b6000610a528385610cf0565b9350610a5f838584610d5e565b610a6883610de7565b840190509392505050565b6000610a7e82610cd4565b610a888185610cdf565b9350610a98818560208601610d6d565b610aa181610de7565b840191505092915050565b6000610ab9602083610d01565b9150610ac482610e05565b602082019050919050565b6000610adc600183610d01565b9150610ae782610e2e565b600182019050919050565b60006060830160008301518482036000860152610b0f8282610a73565b9150506020830151610b2460208601826109fa565b506040830151610b376040860182610b42565b508091505092915050565b610b4b81610d54565b82525050565b610b5a81610d54565b82525050565b6000610b6c8285610a18565b601482019150610b7c8284610a18565b6014820191508190509392505050565b6000610b9782610acf565b9150610ba38285610a18565b601482019150610bb38284610a2f565b602082019150610bc282610aac565b91508190509392505050565b6000602082019050610be36000830184610a09565b92915050565b6000604082019050610bfe6000830185610a09565b610c0b6020830184610b51565b9392505050565b60006080820190508181036000830152610c2c8188610af2565b9050610c3b6020830187610a09565b610c486040830186610b51565b8181036060830152610c5b818486610a46565b90509695505050505050565b6000602082019050610c7c6000830184610b51565b92915050565b6000604082019050610c976000830185610b51565b610ca46020830184610a09565b9392505050565b6000604082019050610cc06000830185610b51565b610ccd6020830184610b51565b9392505050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b6000610d1782610d34565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610d8b578082015181840152602081019050610d70565b83811115610d9a576000848401525b50505050565b6000610dab82610dbc565b9050919050565b6000819050919050565b6000610dc782610df8565b9050919050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f600082015250565b7fff00000000000000000000000000000000000000000000000000000000000000600082015250565b610e6081610d0c565b8114610e6b57600080fd5b50565b610e7781610d1e565b8114610e8257600080fd5b50565b610e8e81610d54565b8114610e9957600080fd5b5056fea2646970667358221220e74d5405ce1c819244378f4290d048a05683c5316d06f7cdbc42ff158e71a57a64736f6c63430008070033", + Bin: "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", } // SystemContractMockABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/zrc20.sol/zrc20.go b/pkg/contracts/zevm/zrc20.sol/zrc20.go index be4f412e..4371221d 100644 --- a/pkg/contracts/zevm/zrc20.sol/zrc20.go +++ b/pkg/contracts/zevm/zrc20.sol/zrc20.go @@ -31,8 +31,8 @@ var ( // ZRC20MetaData contains all meta data concerning the ZRC20 contract. var ZRC20MetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // ZRC20ABI is the input ABI used to generate the binding from. @@ -1723,14 +1723,14 @@ type ZRC20Withdrawal struct { From common.Address To []byte Value *big.Int - Gasfee *big.Int + GasFee *big.Int ProtocolFlatFee *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20 *ZRC20Filterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*ZRC20WithdrawalIterator, error) { var fromRule []interface{} @@ -1747,7 +1747,7 @@ func (_ZRC20 *ZRC20Filterer) FilterWithdrawal(opts *bind.FilterOpts, from []comm // WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20 *ZRC20Filterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ZRC20Withdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} @@ -1789,7 +1789,7 @@ func (_ZRC20 *ZRC20Filterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- * // ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20 *ZRC20Filterer) ParseWithdrawal(log types.Log) (*ZRC20Withdrawal, error) { event := new(ZRC20Withdrawal) if err := _ZRC20.contract.UnpackLog(event, "Withdrawal", log); err != nil { diff --git a/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go b/pkg/contracts/zevm/zrc20new.sol/zrc20errors.go similarity index 100% rename from pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20errors.go rename to pkg/contracts/zevm/zrc20new.sol/zrc20errors.go diff --git a/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go b/pkg/contracts/zevm/zrc20new.sol/zrc20new.go similarity index 99% rename from pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go rename to pkg/contracts/zevm/zrc20new.sol/zrc20new.go index cbf3cefc..728322d3 100644 --- a/pkg/contracts/prototypes/zevm/zrc20new.sol/zrc20new.go +++ b/pkg/contracts/zevm/zrc20new.sol/zrc20new.go @@ -31,8 +31,8 @@ var ( // ZRC20NewMetaData contains all meta data concerning the ZRC20New contract. var ZRC20NewMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gatewayContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GATEWAY_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gatewayContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GATEWAY_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // ZRC20NewABI is the input ABI used to generate the binding from. @@ -1754,14 +1754,14 @@ type ZRC20NewWithdrawal struct { From common.Address To []byte Value *big.Int - Gasfee *big.Int + GasFee *big.Int ProtocolFlatFee *big.Int Raw types.Log // Blockchain specific contextual infos } // FilterWithdrawal is a free log retrieval operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20New *ZRC20NewFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*ZRC20NewWithdrawalIterator, error) { var fromRule []interface{} @@ -1778,7 +1778,7 @@ func (_ZRC20New *ZRC20NewFilterer) FilterWithdrawal(opts *bind.FilterOpts, from // WatchWithdrawal is a free log subscription operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20New *ZRC20NewFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *ZRC20NewWithdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} @@ -1820,7 +1820,7 @@ func (_ZRC20New *ZRC20NewFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink ch // ParseWithdrawal is a log parse operation binding the contract event 0x9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee) +// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasFee, uint256 protocolFlatFee) func (_ZRC20New *ZRC20NewFilterer) ParseWithdrawal(log types.Log) (*ZRC20NewWithdrawal, error) { event := new(ZRC20NewWithdrawal) if err := _ZRC20New.contract.UnpackLog(event, "Withdrawal", log); err != nil { diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 39d20d80..939b9af8 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -1,8 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as gatewayEvmTSol from "./GatewayEVM.t.sol"; -export type { gatewayEvmTSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; diff --git a/typechain-types/contracts/prototypes/index.ts b/typechain-types/contracts/prototypes/index.ts index 9efb820b..31789b58 100644 --- a/typechain-types/contracts/prototypes/index.ts +++ b/typechain-types/contracts/prototypes/index.ts @@ -3,5 +3,7 @@ /* eslint-disable */ import type * as evm from "./evm"; export type { evm }; +import type * as test from "./test"; +export type { test }; import type * as zevm from "./zevm"; export type { zevm }; diff --git a/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest.ts b/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest.ts new file mode 100644 index 00000000..0572c60f --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest.ts @@ -0,0 +1,1023 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface GatewayEVMTestInterface extends utils.Interface { + functions: { + "IS_TEST()": FunctionFragment; + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "failed()": FunctionFragment; + "setUp()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + "testForwardCallToReceivePayable()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "IS_TEST" + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "failed" + | "setUp" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + | "testForwardCallToReceivePayable" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string; + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + encodeFunctionData(functionFragment: "setUp", values?: undefined): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "testForwardCallToReceivePayable", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setUp", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "testForwardCallToReceivePayable", + data: BytesLike + ): Result; + + events: { + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface GatewayEVMTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + IS_TEST(overrides?: CallOverrides): Promise<[boolean]>; + + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + failed(overrides?: CallOverrides): Promise<[boolean]>; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable(overrides?: CallOverrides): Promise; + }; + + filters: { + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testForwardCallToReceivePayable( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/index.ts b/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/index.ts new file mode 100644 index 00000000..5c8fc539 --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { GatewayEVMTest } from "./GatewayEVMTest"; diff --git a/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest.ts b/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest.ts new file mode 100644 index 00000000..5dbb0271 --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest.ts @@ -0,0 +1,1078 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface GatewayIntegrationTestInterface extends utils.Interface { + functions: { + "IS_TEST()": FunctionFragment; + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "failed()": FunctionFragment; + "setUp()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + "testCallReceiverEVMFromZEVM()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "IS_TEST" + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "failed" + | "setUp" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + | "testCallReceiverEVMFromZEVM" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string; + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + encodeFunctionData(functionFragment: "setUp", values?: undefined): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "testCallReceiverEVMFromZEVM", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setUp", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "testCallReceiverEVMFromZEVM", + data: BytesLike + ): Result; + + events: { + "Call(address,bytes,bytes)": EventFragment; + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call(address,bytes,bytes)"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "Call(address,address,bytes)" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface Call_address_bytes_bytes_EventObject { + sender: string; + receiver: string; + message: string; +} +export type Call_address_bytes_bytes_Event = TypedEvent< + [string, string, string], + Call_address_bytes_bytes_EventObject +>; + +export type Call_address_bytes_bytes_EventFilter = + TypedEventFilter; + +export interface Call_address_address_bytes_EventObject { + sender: string; + receiver: string; + payload: string; +} +export type Call_address_address_bytes_Event = TypedEvent< + [string, string, string], + Call_address_address_bytes_EventObject +>; + +export type Call_address_address_bytes_EventFilter = + TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; + message: string; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber, string], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface GatewayIntegrationTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayIntegrationTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + IS_TEST(overrides?: CallOverrides): Promise<[boolean]>; + + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + failed(overrides?: CallOverrides): Promise<[boolean]>; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM(overrides?: CallOverrides): Promise; + }; + + filters: { + "Call(address,bytes,bytes)"( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): Call_address_bytes_bytes_EventFilter; + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): Call_address_address_bytes_EventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts b/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts new file mode 100644 index 00000000..de1fe6cd --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { GatewayIntegrationTest } from "./GatewayIntegrationTest"; diff --git a/typechain-types/contracts/prototypes/test/index.ts b/typechain-types/contracts/prototypes/test/index.ts new file mode 100644 index 00000000..9b2831a4 --- /dev/null +++ b/typechain-types/contracts/prototypes/test/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type * as gatewayEvmTSol from "./GatewayEVM.t.sol"; +export type { gatewayEvmTSol }; +import type * as gatewayIntegrationTSol from "./GatewayIntegration.t.sol"; +export type { gatewayIntegrationTSol }; diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts index e6090cc6..1a6e2455 100644 --- a/typechain-types/contracts/prototypes/zevm/index.ts +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -1,8 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as zrc20NewSol from "./ZRC20New.sol"; -export type { zrc20NewSol }; import type * as interfacesSol from "./interfaces.sol"; export type { interfacesSol }; export type { GatewayZEVM } from "./GatewayZEVM"; diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts new file mode 100644 index 00000000..21a7ccd5 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts @@ -0,0 +1,114 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayZEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "Call(address,bytes,bytes)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + message: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; + message: string; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber, string], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface IGatewayZEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Call(address,bytes,bytes)"( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): CallEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts index 43858d59..973e26af 100644 --- a/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -2,3 +2,4 @@ /* tslint:disable */ /* eslint-disable */ export type { IGatewayZEVM } from "./IGatewayZEVM"; +export type { IGatewayZEVMEvents } from "./IGatewayZEVMEvents"; diff --git a/typechain-types/contracts/zevm/ZRC20.sol/ZRC20.ts b/typechain-types/contracts/zevm/ZRC20.sol/ZRC20.ts index e826c3fe..615255e3 100644 --- a/typechain-types/contracts/zevm/ZRC20.sol/ZRC20.ts +++ b/typechain-types/contracts/zevm/ZRC20.sol/ZRC20.ts @@ -295,7 +295,7 @@ export interface WithdrawalEventObject { from: string; to: string; value: BigNumber; - gasfee: BigNumber; + gasFee: BigNumber; protocolFlatFee: BigNumber; } export type WithdrawalEvent = TypedEvent< @@ -642,14 +642,14 @@ export interface ZRC20 extends BaseContract { from?: PromiseOrValue | null, to?: null, value?: null, - gasfee?: null, + gasFee?: null, protocolFlatFee?: null ): WithdrawalEventFilter; Withdrawal( from?: PromiseOrValue | null, to?: null, value?: null, - gasfee?: null, + gasFee?: null, protocolFlatFee?: null ): WithdrawalEventFilter; }; diff --git a/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20Errors.ts b/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20Errors.ts new file mode 100644 index 00000000..fd71e53f --- /dev/null +++ b/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20Errors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZRC20ErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface ZRC20Errors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZRC20ErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20New.ts b/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20New.ts new file mode 100644 index 00000000..926c4c54 --- /dev/null +++ b/typechain-types/contracts/zevm/ZRC20New.sol/ZRC20New.ts @@ -0,0 +1,854 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZRC20NewInterface extends utils.Interface { + functions: { + "CHAIN_ID()": FunctionFragment; + "COIN_TYPE()": FunctionFragment; + "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; + "GAS_LIMIT()": FunctionFragment; + "GATEWAY_CONTRACT_ADDRESS()": FunctionFragment; + "PROTOCOL_FLAT_FEE()": FunctionFragment; + "SYSTEM_CONTRACT_ADDRESS()": FunctionFragment; + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "burn(uint256)": FunctionFragment; + "decimals()": FunctionFragment; + "deposit(address,uint256)": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + "updateGasLimit(uint256)": FunctionFragment; + "updateProtocolFlatFee(uint256)": FunctionFragment; + "updateSystemContractAddress(address)": FunctionFragment; + "withdraw(bytes,uint256)": FunctionFragment; + "withdrawGasFee()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "CHAIN_ID" + | "COIN_TYPE" + | "FUNGIBLE_MODULE_ADDRESS" + | "GAS_LIMIT" + | "GATEWAY_CONTRACT_ADDRESS" + | "PROTOCOL_FLAT_FEE" + | "SYSTEM_CONTRACT_ADDRESS" + | "allowance" + | "approve" + | "balanceOf" + | "burn" + | "decimals" + | "deposit" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + | "updateGasLimit" + | "updateProtocolFlatFee" + | "updateSystemContractAddress" + | "withdraw" + | "withdrawGasFee" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "CHAIN_ID", values?: undefined): string; + encodeFunctionData(functionFragment: "COIN_TYPE", values?: undefined): string; + encodeFunctionData( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "GAS_LIMIT", values?: undefined): string; + encodeFunctionData( + functionFragment: "GATEWAY_CONTRACT_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "PROTOCOL_FLAT_FEE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "SYSTEM_CONTRACT_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "burn", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "updateGasLimit", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "updateProtocolFlatFee", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "updateSystemContractAddress", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawGasFee", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "CHAIN_ID", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "COIN_TYPE", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "GAS_LIMIT", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "GATEWAY_CONTRACT_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "PROTOCOL_FLAT_FEE", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "SYSTEM_CONTRACT_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateGasLimit", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateProtocolFlatFee", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "updateSystemContractAddress", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawGasFee", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Deposit(bytes,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + "UpdatedGasLimit(uint256)": EventFragment; + "UpdatedProtocolFlatFee(uint256)": EventFragment; + "UpdatedSystemContract(address)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedGasLimit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedProtocolFlatFee"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedSystemContract"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface DepositEventObject { + from: string; + to: string; + value: BigNumber; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface UpdatedGasLimitEventObject { + gasLimit: BigNumber; +} +export type UpdatedGasLimitEvent = TypedEvent< + [BigNumber], + UpdatedGasLimitEventObject +>; + +export type UpdatedGasLimitEventFilter = TypedEventFilter; + +export interface UpdatedProtocolFlatFeeEventObject { + protocolFlatFee: BigNumber; +} +export type UpdatedProtocolFlatFeeEvent = TypedEvent< + [BigNumber], + UpdatedProtocolFlatFeeEventObject +>; + +export type UpdatedProtocolFlatFeeEventFilter = + TypedEventFilter; + +export interface UpdatedSystemContractEventObject { + systemContract: string; +} +export type UpdatedSystemContractEvent = TypedEvent< + [string], + UpdatedSystemContractEventObject +>; + +export type UpdatedSystemContractEventFilter = + TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasFee: BigNumber; + protocolFlatFee: BigNumber; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface ZRC20New extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZRC20NewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + CHAIN_ID(overrides?: CallOverrides): Promise<[BigNumber]>; + + COIN_TYPE(overrides?: CallOverrides): Promise<[number]>; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + GAS_LIMIT(overrides?: CallOverrides): Promise<[BigNumber]>; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + + callStatic: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Deposit(bytes,address,uint256)"( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + Deposit( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + + "UpdatedGasLimit(uint256)"(gasLimit?: null): UpdatedGasLimitEventFilter; + UpdatedGasLimit(gasLimit?: null): UpdatedGasLimitEventFilter; + + "UpdatedProtocolFlatFee(uint256)"( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + UpdatedProtocolFlatFee( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + + "UpdatedSystemContract(address)"( + systemContract?: null + ): UpdatedSystemContractEventFilter; + UpdatedSystemContract( + systemContract?: null + ): UpdatedSystemContractEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasFee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasFee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + }; + + estimateGas: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + CHAIN_ID(overrides?: CallOverrides): Promise; + + COIN_TYPE(overrides?: CallOverrides): Promise; + + FUNGIBLE_MODULE_ADDRESS( + overrides?: CallOverrides + ): Promise; + + GAS_LIMIT(overrides?: CallOverrides): Promise; + + GATEWAY_CONTRACT_ADDRESS( + overrides?: CallOverrides + ): Promise; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + SYSTEM_CONTRACT_ADDRESS( + overrides?: CallOverrides + ): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateGasLimit( + gasLimit: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateProtocolFlatFee( + protocolFlatFee: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + updateSystemContractAddress( + addr: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/zevm/ZRC20New.sol/index.ts b/typechain-types/contracts/zevm/ZRC20New.sol/index.ts new file mode 100644 index 00000000..ea6138df --- /dev/null +++ b/typechain-types/contracts/zevm/ZRC20New.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { ZRC20Errors } from "./ZRC20Errors"; +export type { ZRC20New } from "./ZRC20New"; diff --git a/typechain-types/contracts/zevm/index.ts b/typechain-types/contracts/zevm/index.ts index c1e5459a..7bead7ac 100644 --- a/typechain-types/contracts/zevm/index.ts +++ b/typechain-types/contracts/zevm/index.ts @@ -1,14 +1,14 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as interfacesSol from "./Interfaces.sol"; -export type { interfacesSol }; import type * as systemContractSol from "./SystemContract.sol"; export type { systemContractSol }; import type * as wzetaSol from "./WZETA.sol"; export type { wzetaSol }; import type * as zrc20Sol from "./ZRC20.sol"; export type { zrc20Sol }; +import type * as zrc20NewSol from "./ZRC20New.sol"; +export type { zrc20NewSol }; import type * as zetaConnectorZevmSol from "./ZetaConnectorZEVM.sol"; export type { zetaConnectorZevmSol }; import type * as interfaces from "./interfaces"; diff --git a/typechain-types/contracts/zevm/interfaces/ISystem.ts b/typechain-types/contracts/zevm/interfaces/ISystem.ts new file mode 100644 index 00000000..00b55b29 --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/ISystem.ts @@ -0,0 +1,243 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ISystemInterface extends utils.Interface { + functions: { + "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; + "gasCoinZRC20ByChainId(uint256)": FunctionFragment; + "gasPriceByChainId(uint256)": FunctionFragment; + "gasZetaPoolByChainId(uint256)": FunctionFragment; + "uniswapv2FactoryAddress()": FunctionFragment; + "wZetaContractAddress()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "FUNGIBLE_MODULE_ADDRESS" + | "gasCoinZRC20ByChainId" + | "gasPriceByChainId" + | "gasZetaPoolByChainId" + | "uniswapv2FactoryAddress" + | "wZetaContractAddress" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "gasCoinZRC20ByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "gasPriceByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "gasZetaPoolByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "uniswapv2FactoryAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "wZetaContractAddress", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasCoinZRC20ByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasPriceByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasZetaPoolByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "uniswapv2FactoryAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "wZetaContractAddress", + data: BytesLike + ): Result; + + events: {}; +} + +export interface ISystem extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ISystemInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise<[string]>; + + wZetaContractAddress(overrides?: CallOverrides): Promise<[string]>; + }; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + + callStatic: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + FUNGIBLE_MODULE_ADDRESS( + overrides?: CallOverrides + ): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress( + overrides?: CallOverrides + ): Promise; + + wZetaContractAddress( + overrides?: CallOverrides + ): Promise; + }; +} diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ISystem.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ISystem.ts new file mode 100644 index 00000000..82bef724 --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ISystem.ts @@ -0,0 +1,243 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface ISystemInterface extends utils.Interface { + functions: { + "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; + "gasCoinZRC20ByChainId(uint256)": FunctionFragment; + "gasPriceByChainId(uint256)": FunctionFragment; + "gasZetaPoolByChainId(uint256)": FunctionFragment; + "uniswapv2FactoryAddress()": FunctionFragment; + "wZetaContractAddress()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "FUNGIBLE_MODULE_ADDRESS" + | "gasCoinZRC20ByChainId" + | "gasPriceByChainId" + | "gasZetaPoolByChainId" + | "uniswapv2FactoryAddress" + | "wZetaContractAddress" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "gasCoinZRC20ByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "gasPriceByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "gasZetaPoolByChainId", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "uniswapv2FactoryAddress", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "wZetaContractAddress", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "FUNGIBLE_MODULE_ADDRESS", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasCoinZRC20ByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasPriceByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "gasZetaPoolByChainId", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "uniswapv2FactoryAddress", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "wZetaContractAddress", + data: BytesLike + ): Result; + + events: {}; +} + +export interface ISystem extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ISystemInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise<[string]>; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[string]>; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise<[string]>; + + wZetaContractAddress(overrides?: CallOverrides): Promise<[string]>; + }; + + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + + callStatic: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + }; + + filters: {}; + + estimateGas: { + FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress(overrides?: CallOverrides): Promise; + + wZetaContractAddress(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + FUNGIBLE_MODULE_ADDRESS( + overrides?: CallOverrides + ): Promise; + + gasCoinZRC20ByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasPriceByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + gasZetaPoolByChainId( + chainID: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + uniswapv2FactoryAddress( + overrides?: CallOverrides + ): Promise; + + wZetaContractAddress( + overrides?: CallOverrides + ): Promise; + }; +} diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20.ts new file mode 100644 index 00000000..7950ed9e --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20.ts @@ -0,0 +1,432 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IZRC20Interface extends utils.Interface { + functions: { + "PROTOCOL_FLAT_FEE()": FunctionFragment; + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "burn(uint256)": FunctionFragment; + "deposit(address,uint256)": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + "withdraw(bytes,uint256)": FunctionFragment; + "withdrawGasFee()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "PROTOCOL_FLAT_FEE" + | "allowance" + | "approve" + | "balanceOf" + | "burn" + | "deposit" + | "totalSupply" + | "transfer" + | "transferFrom" + | "withdraw" + | "withdrawGasFee" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "PROTOCOL_FLAT_FEE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "burn", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deposit", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawGasFee", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "PROTOCOL_FLAT_FEE", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawGasFee", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IZRC20 extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IZRC20Interface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + + callStatic: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + filters: {}; + + estimateGas: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata.ts new file mode 100644 index 00000000..52d988ca --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata.ts @@ -0,0 +1,474 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IZRC20MetadataInterface extends utils.Interface { + functions: { + "PROTOCOL_FLAT_FEE()": FunctionFragment; + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "burn(uint256)": FunctionFragment; + "decimals()": FunctionFragment; + "deposit(address,uint256)": FunctionFragment; + "name()": FunctionFragment; + "symbol()": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + "withdraw(bytes,uint256)": FunctionFragment; + "withdrawGasFee()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "PROTOCOL_FLAT_FEE" + | "allowance" + | "approve" + | "balanceOf" + | "burn" + | "decimals" + | "deposit" + | "name" + | "symbol" + | "totalSupply" + | "transfer" + | "transferFrom" + | "withdraw" + | "withdrawGasFee" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "PROTOCOL_FLAT_FEE", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "burn", + values: [PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "decimals", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData(functionFragment: "name", values?: undefined): string; + encodeFunctionData(functionFragment: "symbol", values?: undefined): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawGasFee", + values?: undefined + ): string; + + decodeFunctionResult( + functionFragment: "PROTOCOL_FLAT_FEE", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "name", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "symbol", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawGasFee", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IZRC20Metadata extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IZRC20MetadataInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise<[BigNumber]>; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise<[number]>; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise<[string]>; + + symbol(overrides?: CallOverrides): Promise<[string]>; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + + callStatic: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise<[string, BigNumber]>; + }; + + filters: {}; + + estimateGas: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + PROTOCOL_FLAT_FEE(overrides?: CallOverrides): Promise; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burn( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + decimals(overrides?: CallOverrides): Promise; + + deposit( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + name(overrides?: CallOverrides): Promise; + + symbol(overrides?: CallOverrides): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + sender: PromiseOrValue, + recipient: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawGasFee(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events.ts new file mode 100644 index 00000000..ad5bc65f --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events.ts @@ -0,0 +1,219 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface ZRC20EventsInterface extends utils.Interface { + functions: {}; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Deposit(bytes,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + "UpdatedGasLimit(uint256)": EventFragment; + "UpdatedProtocolFlatFee(uint256)": EventFragment; + "UpdatedSystemContract(address)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedGasLimit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedProtocolFlatFee"): EventFragment; + getEvent(nameOrSignatureOrTopic: "UpdatedSystemContract"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface DepositEventObject { + from: string; + to: string; + value: BigNumber; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface UpdatedGasLimitEventObject { + gasLimit: BigNumber; +} +export type UpdatedGasLimitEvent = TypedEvent< + [BigNumber], + UpdatedGasLimitEventObject +>; + +export type UpdatedGasLimitEventFilter = TypedEventFilter; + +export interface UpdatedProtocolFlatFeeEventObject { + protocolFlatFee: BigNumber; +} +export type UpdatedProtocolFlatFeeEvent = TypedEvent< + [BigNumber], + UpdatedProtocolFlatFeeEventObject +>; + +export type UpdatedProtocolFlatFeeEventFilter = + TypedEventFilter; + +export interface UpdatedSystemContractEventObject { + systemContract: string; +} +export type UpdatedSystemContractEvent = TypedEvent< + [string], + UpdatedSystemContractEventObject +>; + +export type UpdatedSystemContractEventFilter = + TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasFee: BigNumber; + protocolFlatFee: BigNumber; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface ZRC20Events extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZRC20EventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Deposit(bytes,address,uint256)"( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + Deposit( + from?: null, + to?: PromiseOrValue | null, + value?: null + ): DepositEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + + "UpdatedGasLimit(uint256)"(gasLimit?: null): UpdatedGasLimitEventFilter; + UpdatedGasLimit(gasLimit?: null): UpdatedGasLimitEventFilter; + + "UpdatedProtocolFlatFee(uint256)"( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + UpdatedProtocolFlatFee( + protocolFlatFee?: null + ): UpdatedProtocolFlatFeeEventFilter; + + "UpdatedSystemContract(address)"( + systemContract?: null + ): UpdatedSystemContractEventFilter; + UpdatedSystemContract( + systemContract?: null + ): UpdatedSystemContractEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasFee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasFee?: null, + protocolFlatFee?: null + ): WithdrawalEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts new file mode 100644 index 00000000..0a0567e2 --- /dev/null +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { ISystem } from "./ISystem"; +export type { IZRC20 } from "./IZRC20"; +export type { IZRC20Metadata } from "./IZRC20Metadata"; +export type { ZRC20Events } from "./ZRC20Events"; diff --git a/typechain-types/contracts/zevm/interfaces/index.ts b/typechain-types/contracts/zevm/interfaces/index.ts index 5328b2e6..8d5dd390 100644 --- a/typechain-types/contracts/zevm/interfaces/index.ts +++ b/typechain-types/contracts/zevm/interfaces/index.ts @@ -3,7 +3,9 @@ /* eslint-disable */ import type * as iwzetaSol from "./IWZETA.sol"; export type { iwzetaSol }; +import type * as izrc20Sol from "./IZRC20.sol"; +export type { izrc20Sol }; +export type { ISystem } from "./ISystem"; export type { IUniswapV2Router01 } from "./IUniswapV2Router01"; export type { IUniswapV2Router02 } from "./IUniswapV2Router02"; -export type { IZRC20 } from "./IZRC20"; export type { ZContract } from "./ZContract"; diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index 10853123..b7a35400 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -1,7 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as gatewayEvmTSol from "./GatewayEVM.t.sol"; export * as interfacesSol from "./interfaces.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; diff --git a/typechain-types/factories/contracts/prototypes/index.ts b/typechain-types/factories/contracts/prototypes/index.ts index 33289123..242fb084 100644 --- a/typechain-types/factories/contracts/prototypes/index.ts +++ b/typechain-types/factories/contracts/prototypes/index.ts @@ -2,4 +2,5 @@ /* tslint:disable */ /* eslint-disable */ export * as evm from "./evm"; +export * as test from "./test"; export * as zevm from "./zevm"; diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts new file mode 100644 index 00000000..ea6cea4b --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -0,0 +1,910 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../../common"; +import type { + GatewayEVMTest, + GatewayEVMTestInterface, +} from "../../../../../contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "IS_TEST", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "setUp", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "testForwardCallToReceivePayable", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVMTest__factory extends ContractFactory { + constructor(...args: GatewayEVMTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVMTest { + return super.attach(address) as GatewayEVMTest; + } + override connect(signer: Signer): GatewayEVMTest__factory { + return super.connect(signer) as GatewayEVMTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMTestInterface { + return new utils.Interface(_abi) as GatewayEVMTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVMTest { + return new Contract(address, _abi, signerOrProvider) as GatewayEVMTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/index.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/index.ts new file mode 100644 index 00000000..9427818e --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { GatewayEVMTest__factory } from "./GatewayEVMTest__factory"; diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory.ts new file mode 100644 index 00000000..d4983137 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory.ts @@ -0,0 +1,982 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../../common"; +import type { + GatewayIntegrationTest, + GatewayIntegrationTestInterface, +} from "../../../../../contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "IS_TEST", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "setUp", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "testCallReceiverEVMFromZEVM", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "0x60806040526001600c60006101000a81548160ff0219169083151502179055506001601f60006101000a81548160ff02191690831515021790555034801561004657600080fd5b506201142f80620000586000396000f3fe60806040523480156200001157600080fd5b5060043610620001005760003560e01c8063916a17c61162000099578063b5508aa9116200006f578063b5508aa9146200022d578063ba414fa6146200024f578063e20c9f711462000271578063fa7626d414620002935762000100565b8063916a17c614620001dd5780639683c69514620001ff578063b0464fdc146200020b5762000100565b80633e5e3c2311620000db5780633e5e3c2314620001555780633f7286f4146200017757806366d9a9a0146200019957806385226c8114620001bb5762000100565b80630a9254e414620001055780631ed7831c14620001115780632ade38801462000133575b600080fd5b6200010f620002b5565b005b6200011b620010b4565b6040516200012a919062002c9b565b60405180910390f35b6200013d62001144565b6040516200014c919062002d07565b60405180910390f35b6200015f620012de565b6040516200016e919062002c9b565b60405180910390f35b620001816200136e565b60405162000190919062002c9b565b60405180910390f35b620001a3620013fe565b604051620001b2919062002ce3565b60405180910390f35b620001c562001595565b604051620001d4919062002cbf565b60405180910390f35b620001e762001678565b604051620001f6919062002d2b565b60405180910390f35b62000209620017cb565b005b6200021562001e6a565b60405162000224919062002d2b565b60405180910390f35b6200023762001fbd565b60405162000246919062002cbf565b60405180910390f35b62000259620020a0565b60405162000268919062002d4f565b60405180910390f35b6200027b620021d3565b6040516200028a919062002c9b565b60405180910390f35b6200029d62002263565b604051620002ac919062002d4f565b60405180910390f35b30602360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550611234602460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550615678602560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550614321602a60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620003cd9062002276565b620003d89062002f3a565b604051809103906000f080158015620003f5573d6000803e3d6000fd5b50602160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620004449062002284565b604051809103906000f08015801562000461573d6000803e3d6000fd5b50601f60016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16604051620004d39062002292565b620004df919062002b59565b604051809103906000f080158015620004fc573d6000803e3d6000fd5b50602060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c4d66de8602560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401620005bc919062002b59565b600060405180830381600087803b158015620005d757600080fd5b505af1158015620005ec573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ae7a3a6f602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200066f919062002b59565b600060405180830381600087803b1580156200068a57600080fd5b505af11580156200069f573d6000803e3d6000fd5b50505050602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b81526004016200072792919062002c14565b600060405180830381600087803b1580156200074257600080fd5b505af115801562000757573d6000803e3d6000fd5b50505050602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166207a1206040518363ffffffff1660e01b8152600401620007df92919062002c41565b602060405180830381600087803b158015620007fa57600080fd5b505af11580156200080f573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000835919062002392565b506040516200084490620022a0565b604051809103906000f08015801562000861573d6000803e3d6000fd5b50602260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620008b090620022ae565b604051809103906000f080158015620008cd573d6000803e3d6000fd5b50602660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516200093f90620022bc565b6200094b919062002b59565b604051809103906000f08015801562000968573d6000803e3d6000fd5b50602760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600073735b14bb79463307aacbed86daf3322b1e6226ab90507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166306447d56826040518263ffffffff1660e01b815260040162000a20919062002b59565b600060405180830381600087803b15801562000a3b57600080fd5b505af115801562000a50573d6000803e3d6000fd5b50505050600080600060405162000a6790620022ca565b62000a759392919062002b76565b604051809103906000f08015801562000a92573d6000803e3d6000fd5b50602860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060126001600080602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405162000b2e90620022d8565b62000b3f9695949392919062002ea2565b604051809103906000f08015801562000b5c573d6000803e3d6000fd5b50602960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ee2815ba6001602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518363ffffffff1660e01b815260040162000c1f92919062002e04565b600060405180830381600087803b15801562000c3a57600080fd5b505af115801562000c4f573d6000803e3d6000fd5b50505050602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a7cb05076001806040518363ffffffff1660e01b815260040162000cb392919062002e31565b600060405180830381600087803b15801562000cce57600080fd5b505af115801562000ce3573d6000803e3d6000fd5b50505050602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166347e7ef24602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b815260040162000d6b92919062002c14565b602060405180830381600087803b15801562000d8657600080fd5b505af115801562000d9b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000dc1919062002392565b50602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166347e7ef24602760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b815260040162000e4692919062002c14565b602060405180830381600087803b15801562000e6157600080fd5b505af115801562000e76573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000e9c919062002392565b507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166390c5013b6040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562000f0957600080fd5b505af115801562000f1e573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663ca669fa7602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b815260040162000fa2919062002b59565b600060405180830381600087803b15801562000fbd57600080fd5b505af115801562000fd2573d6000803e3d6000fd5b50505050602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663095ea7b3602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b81526004016200105a92919062002c14565b602060405180830381600087803b1580156200107557600080fd5b505af11580156200108a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620010b0919062002392565b5050565b606060168054806020026020016040519081016040528092919081815260200182805480156200113a57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620010ef575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020016000905b82821015620012d557838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020016000905b82821015620012bd578382906000526020600020018054620012299062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620012579062003340565b8015620012a85780601f106200127c57610100808354040283529160200191620012a8565b820191906000526020600020905b8154815290600101906020018083116200128a57829003601f168201915b50505050508152602001906001019062001207565b50505050815250508152602001906001019062001168565b50505050905090565b606060188054806020026020016040519081016040528092919081815260200182805480156200136457602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162001319575b5050505050905090565b60606017805480602002602001604051908101604052809291908181526020018280548015620013f457602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620013a9575b5050505050905090565b6060601b805480602002602001604051908101604052809291908181526020016000905b828210156200158c5783829060005260206000209060020201604051806040016040529081600082018054620014589062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620014869062003340565b8015620014d75780601f10620014ab57610100808354040283529160200191620014d7565b820191906000526020600020905b815481529060010190602001808311620014b957829003601f168201915b50505050508152602001600182018054806020026020016040519081016040528092919081815260200182805480156200157357602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116200151f5790505b5050505050815250508152602001906001019062001422565b50505050905090565b6060601a805480602002602001604051908101604052809291908181526020016000905b828210156200166f578382906000526020600020018054620015db9062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620016099062003340565b80156200165a5780601f106200162e576101008083540402835291602001916200165a565b820191906000526020600020905b8154815290600101906020018083116200163c57829003601f168201915b505050505081526020019060010190620015b9565b50505050905090565b6060601d805480602002602001604051908101604052809291908181526020016000905b82821015620017c257838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020018280548015620017a957602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411620017555790505b505050505081525050815260200190600101906200169c565b50505050905090565b60006040518060400160405280600f81526020017f48656c6c6f2c204861726468617421000000000000000000000000000000000081525090506000602a90506000600190506000670de0b6b3a76400009050600063e04d4f9760e01b8585856040516024016200183f9392919062002e5e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663ca669fa7602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200191e919062002b59565b600060405180830381600087803b1580156200193957600080fd5b505af11580156200194e573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b8152600401620019dc95949392919062002d6c565b600060405180830381600087803b158015620019f757600080fd5b505af115801562001a0c573d6000803e3d6000fd5b50505050602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405160200162001a9f919062002b3c565b6040516020818303038152906040528360405162001abf92919062002dc9565b60405180910390a2602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405160200162001b3a919062002b3c565b604051602081830303815290604052836040518363ffffffff1660e01b815260040162001b6992919062002dc9565b600060405180830381600087803b15801562001b8457600080fd5b505af115801562001b99573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663c88a5e6d601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518363ffffffff1660e01b815260040162001c1f92919062002c6e565b600060405180830381600087803b15801562001c3a57600080fd5b505af115801562001c4f573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b815260040162001cdd95949392919062002d6c565b600060405180830381600087803b15801562001cf857600080fd5b505af115801562001d0d573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f838360405162001d7d92919062002f71565b60405180910390a2601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16631cff79cd83602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b815260040162001e0792919062002be0565b6000604051808303818588803b15801562001e2157600080fd5b505af115801562001e36573d6000803e3d6000fd5b50505050506040513d6000823e3d601f19601f8201168201806040525081019062001e629190620023f6565b505050505050565b6060601c805480602002602001604051908101604052809291908181526020016000905b8282101562001fb457838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020016001820180548060200260200160405190810160405280929190818152602001828054801562001f9b57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162001f475790505b5050505050815250508152602001906001019062001e8e565b50505050905090565b60606019805480602002602001604051908101604052809291908181526020016000905b8282101562002097578382906000526020600020018054620020039062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620020319062003340565b8015620020825780601f10620020565761010080835404028352916020019162002082565b820191906000526020600020905b8154815290600101906020018083116200206457829003601f168201915b50505050508152602001906001019062001fe1565b50505050905090565b6000600860009054906101000a900460ff1615620020d057600860009054906101000a900460ff169050620021d0565b6000801b7f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663667f9d707f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c7f6661696c656400000000000000000000000000000000000000000000000000006040518363ffffffff1660e01b81526004016200217792919062002bb3565b60206040518083038186803b1580156200219057600080fd5b505afa158015620021a5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620021cb9190620023c4565b141590505b90565b606060158054806020026020016040519081016040528092919081815260200182805480156200225957602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190600101908083116200220e575b5050505050905090565b601f60009054906101000a900460ff1681565b611813806200358383390190565b6131a48062004d9683390190565b6110908062007f3a83390190565b6110aa8062008fca83390190565b612eb5806200a07483390190565b610bcd806200cf2983390190565b6110d7806200daf683390190565b61282d806200ebcd83390190565b6000620022fd620022f78462002fce565b62002fa5565b9050828152602081018484840111156200231c576200231b62003466565b5b620023298482856200330a565b509392505050565b60008151905062002342816200354e565b92915050565b600081519050620023598162003568565b92915050565b600082601f83011262002377576200237662003461565b5b815162002389848260208601620022e6565b91505092915050565b600060208284031215620023ab57620023aa62003470565b5b6000620023bb8482850162002331565b91505092915050565b600060208284031215620023dd57620023dc62003470565b5b6000620023ed8482850162002348565b91505092915050565b6000602082840312156200240f576200240e62003470565b5b600082015167ffffffffffffffff81111562002430576200242f6200346b565b5b6200243e848285016200235f565b91505092915050565b6000620024558383620024d3565b60208301905092915050565b60006200246f838362002870565b60208301905092915050565b600062002489838362002943565b905092915050565b60006200249f838362002a61565b905092915050565b6000620024b5838362002aa9565b905092915050565b6000620024cb838362002aea565b905092915050565b620024de81620031b4565b82525050565b620024ef81620031b4565b82525050565b6000620025028262003064565b6200250e81856200310a565b93506200251b8362003004565b8060005b838110156200255257815162002536888262002447565b97506200254383620030bc565b9250506001810190506200251f565b5085935050505092915050565b60006200256c826200306f565b6200257881856200311b565b9350620025858362003014565b8060005b83811015620025bc578151620025a0888262002461565b9750620025ad83620030c9565b92505060018101905062002589565b5085935050505092915050565b6000620025d6826200307a565b620025e281856200312c565b935083602082028501620025f68562003024565b8060005b858110156200263857848403895281516200261685826200247b565b94506200262383620030d6565b925060208a01995050600181019050620025fa565b50829750879550505050505092915050565b600062002657826200307a565b6200266381856200313d565b935083602082028501620026778562003024565b8060005b85811015620026b957848403895281516200269785826200247b565b9450620026a483620030d6565b925060208a019950506001810190506200267b565b50829750879550505050505092915050565b6000620026d88262003085565b620026e481856200314e565b935083602082028501620026f88562003034565b8060005b858110156200273a578484038952815162002718858262002491565b94506200272583620030e3565b925060208a01995050600181019050620026fc565b50829750879550505050505092915050565b6000620027598262003090565b6200276581856200315f565b935083602082028501620027798562003044565b8060005b85811015620027bb5784840389528151620027998582620024a7565b9450620027a683620030f0565b925060208a019950506001810190506200277d565b50829750879550505050505092915050565b6000620027da826200309b565b620027e6818562003170565b935083602082028501620027fa8562003054565b8060005b858110156200283c57848403895281516200281a8582620024bd565b94506200282783620030fd565b925060208a01995050600181019050620027fe565b50829750879550505050505092915050565b6200285981620031c8565b82525050565b6200286a81620031d4565b82525050565b6200287b81620031de565b82525050565b60006200288e82620030a6565b6200289a818562003181565b9350620028ac8185602086016200330a565b620028b78162003475565b840191505092915050565b620028d7620028d18262003256565b620033ac565b82525050565b620028e8816200326a565b82525050565b620028f9816200327e565b82525050565b6200290a8162003292565b82525050565b6200291b81620032a6565b82525050565b6200292c81620032ba565b82525050565b6200293d81620032ce565b82525050565b60006200295082620030b1565b6200295c818562003192565b93506200296e8185602086016200330a565b620029798162003475565b840191505092915050565b60006200299182620030b1565b6200299d8185620031a3565b9350620029af8185602086016200330a565b620029ba8162003475565b840191505092915050565b6000620029d4600383620031a3565b9150620029e18262003493565b602082019050919050565b6000620029fb600583620031a3565b915062002a0882620034bc565b602082019050919050565b600062002a22600483620031a3565b915062002a2f82620034e5565b602082019050919050565b600062002a49600383620031a3565b915062002a56826200350e565b602082019050919050565b6000604083016000830151848203600086015262002a80828262002943565b9150506020830151848203602086015262002a9c82826200255f565b9150508091505092915050565b600060408301600083015162002ac36000860182620024d3565b506020830151848203602086015262002add8282620025c9565b9150508091505092915050565b600060408301600083015162002b046000860182620024d3565b506020830151848203602086015262002b1e82826200255f565b9150508091505092915050565b62002b36816200323f565b82525050565b600062002b4a8284620028c2565b60148201915081905092915050565b600060208201905062002b706000830184620024e4565b92915050565b600060608201905062002b8d6000830186620024e4565b62002b9c6020830185620024e4565b62002bab6040830184620024e4565b949350505050565b600060408201905062002bca6000830185620024e4565b62002bd960208301846200285f565b9392505050565b600060408201905062002bf76000830185620024e4565b818103602083015262002c0b818462002881565b90509392505050565b600060408201905062002c2b6000830185620024e4565b62002c3a6020830184620028ff565b9392505050565b600060408201905062002c586000830185620024e4565b62002c67602083018462002932565b9392505050565b600060408201905062002c856000830185620024e4565b62002c94602083018462002b2b565b9392505050565b6000602082019050818103600083015262002cb78184620024f5565b905092915050565b6000602082019050818103600083015262002cdb81846200264a565b905092915050565b6000602082019050818103600083015262002cff8184620026cb565b905092915050565b6000602082019050818103600083015262002d2381846200274c565b905092915050565b6000602082019050818103600083015262002d478184620027cd565b905092915050565b600060208201905062002d6660008301846200284e565b92915050565b600060a08201905062002d8360008301886200284e565b62002d9260208301876200284e565b62002da160408301866200284e565b62002db060608301856200284e565b62002dbf6080830184620024e4565b9695505050505050565b6000604082019050818103600083015262002de5818562002881565b9050818103602083015262002dfb818462002881565b90509392505050565b600060408201905062002e1b600083018562002921565b62002e2a6020830184620024e4565b9392505050565b600060408201905062002e48600083018562002921565b62002e57602083018462002921565b9392505050565b6000606082019050818103600083015262002e7a818662002984565b905062002e8b602083018562002b2b565b62002e9a60408301846200284e565b949350505050565b600061010082019050818103600083015262002ebe81620029ec565b9050818103602083015262002ed38162002a3a565b905062002ee4604083018962002910565b62002ef3606083018862002921565b62002f026080830187620028dd565b62002f1160a0830186620028ee565b62002f2060c0830185620024e4565b62002f2f60e0830184620024e4565b979650505050505050565b6000604082019050818103600083015262002f558162002a13565b9050818103602083015262002f6a81620029c5565b9050919050565b600060408201905062002f88600083018562002b2b565b818103602083015262002f9c818462002881565b90509392505050565b600062002fb162002fc4565b905062002fbf828262003376565b919050565b6000604051905090565b600067ffffffffffffffff82111562002fec5762002feb62003432565b5b62002ff78262003475565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000620031c1826200321f565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b60008190506200321a8262003537565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006200326382620032e2565b9050919050565b600062003277826200320a565b9050919050565b60006200328b826200323f565b9050919050565b60006200329f826200323f565b9050919050565b6000620032b38262003249565b9050919050565b6000620032c7826200323f565b9050919050565b6000620032db826200323f565b9050919050565b6000620032ef82620032f6565b9050919050565b600062003303826200321f565b9050919050565b60005b838110156200332a5780820151818401526020810190506200330d565b838111156200333a576000848401525b50505050565b600060028204905060018216806200335957607f821691505b6020821081141562003370576200336f62003403565b5b50919050565b620033818262003475565b810181811067ffffffffffffffff82111715620033a357620033a262003432565b5b80604052505050565b6000620033b982620033c0565b9050919050565b6000620033cd8262003486565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f54544b0000000000000000000000000000000000000000000000000000000000600082015250565b7f544f4b454e000000000000000000000000000000000000000000000000000000600082015250565b7f7465737400000000000000000000000000000000000000000000000000000000600082015250565b7f544b4e0000000000000000000000000000000000000000000000000000000000600082015250565b600381106200354b576200354a620033d4565b5b50565b6200355981620031c8565b81146200356557600080fd5b50565b6200357381620031d4565b81146200357f57600080fd5b5056fe60806040523480156200001157600080fd5b5060405162001813380380620018138339818101604052810190620000379190620001a3565b818181600390805190602001906200005192919062000075565b5080600490805190602001906200006a92919062000075565b5050505050620003ac565b8280546200008390620002bd565b90600052602060002090601f016020900481019282620000a75760008555620000f3565b82601f10620000c257805160ff1916838001178555620000f3565b82800160010185558215620000f3579182015b82811115620000f2578251825591602001919060010190620000d5565b5b50905062000102919062000106565b5090565b5b808211156200012157600081600090555060010162000107565b5090565b60006200013c620001368462000251565b62000228565b9050828152602081018484840111156200015b576200015a6200038c565b5b6200016884828562000287565b509392505050565b600082601f83011262000188576200018762000387565b5b81516200019a84826020860162000125565b91505092915050565b60008060408385031215620001bd57620001bc62000396565b5b600083015167ffffffffffffffff811115620001de57620001dd62000391565b5b620001ec8582860162000170565b925050602083015167ffffffffffffffff81111562000210576200020f62000391565b5b6200021e8582860162000170565b9150509250929050565b60006200023462000247565b9050620002428282620002f3565b919050565b6000604051905090565b600067ffffffffffffffff8211156200026f576200026e62000358565b5b6200027a826200039b565b9050602081019050919050565b60005b83811015620002a75780820151818401526020810190506200028a565b83811115620002b7576000848401525b50505050565b60006002820490506001821680620002d657607f821691505b60208210811415620002ed57620002ec62000329565b5b50919050565b620002fe826200039b565b810181811067ffffffffffffffff8211171562000320576200031f62000358565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b61145780620003bc6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c806340c10f191161007157806340c10f19146101a357806370a08231146101bf57806395d89b41146101ef578063a457c2d71461020d578063a9059cbb1461023d578063dd62ed3e1461026d576100b4565b806306fdde03146100b9578063095ea7b3146100d757806318160ddd1461010757806323b872dd14610125578063313ce567146101555780633950935114610173575b600080fd5b6100c161029d565b6040516100ce9190610ecf565b60405180910390f35b6100f160048036038101906100ec9190610cf6565b61032f565b6040516100fe9190610eb4565b60405180910390f35b61010f610352565b60405161011c9190610ff1565b60405180910390f35b61013f600480360381019061013a9190610ca3565b61035c565b60405161014c9190610eb4565b60405180910390f35b61015d61038b565b60405161016a919061100c565b60405180910390f35b61018d60048036038101906101889190610cf6565b610394565b60405161019a9190610eb4565b60405180910390f35b6101bd60048036038101906101b89190610cf6565b6103cb565b005b6101d960048036038101906101d49190610c36565b6103d9565b6040516101e69190610ff1565b60405180910390f35b6101f7610421565b6040516102049190610ecf565b60405180910390f35b61022760048036038101906102229190610cf6565b6104b3565b6040516102349190610eb4565b60405180910390f35b61025760048036038101906102529190610cf6565b61052a565b6040516102649190610eb4565b60405180910390f35b61028760048036038101906102829190610c63565b61054d565b6040516102949190610ff1565b60405180910390f35b6060600380546102ac90611121565b80601f01602080910402602001604051908101604052809291908181526020018280546102d890611121565b80156103255780601f106102fa57610100808354040283529160200191610325565b820191906000526020600020905b81548152906001019060200180831161030857829003601f168201915b5050505050905090565b60008061033a6105d4565b90506103478185856105dc565b600191505092915050565b6000600254905090565b6000806103676105d4565b90506103748582856107a7565b61037f858585610833565b60019150509392505050565b60006012905090565b60008061039f6105d4565b90506103c08185856103b1858961054d565b6103bb9190611043565b6105dc565b600191505092915050565b6103d58282610aab565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60606004805461043090611121565b80601f016020809104026020016040519081016040528092919081815260200182805461045c90611121565b80156104a95780601f1061047e576101008083540402835291602001916104a9565b820191906000526020600020905b81548152906001019060200180831161048c57829003601f168201915b5050505050905090565b6000806104be6105d4565b905060006104cc828661054d565b905083811015610511576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050890610fb1565b60405180910390fd5b61051e82868684036105dc565b60019250505092915050565b6000806105356105d4565b9050610542818585610833565b600191505092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610f91565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156106bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106b390610f11565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161079a9190610ff1565b60405180910390a3505050565b60006107b3848461054d565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461082d578181101561081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690610f31565b60405180910390fd5b61082c84848484036105dc565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156108a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089a90610f71565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610913576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090a90610ef1565b60405180910390fd5b61091e838383610c02565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156109a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099b90610f51565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a929190610ff1565b60405180910390a3610aa5848484610c07565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610b1b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1290610fd1565b60405180910390fd5b610b2760008383610c02565b8060026000828254610b399190611043565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051610bea9190610ff1565b60405180910390a3610bfe60008383610c07565b5050565b505050565b505050565b600081359050610c1b816113f3565b92915050565b600081359050610c308161140a565b92915050565b600060208284031215610c4c57610c4b6111b1565b5b6000610c5a84828501610c0c565b91505092915050565b60008060408385031215610c7a57610c796111b1565b5b6000610c8885828601610c0c565b9250506020610c9985828601610c0c565b9150509250929050565b600080600060608486031215610cbc57610cbb6111b1565b5b6000610cca86828701610c0c565b9350506020610cdb86828701610c0c565b9250506040610cec86828701610c21565b9150509250925092565b60008060408385031215610d0d57610d0c6111b1565b5b6000610d1b85828601610c0c565b9250506020610d2c85828601610c21565b9150509250929050565b610d3f816110ab565b82525050565b6000610d5082611027565b610d5a8185611032565b9350610d6a8185602086016110ee565b610d73816111b6565b840191505092915050565b6000610d8b602383611032565b9150610d96826111c7565b604082019050919050565b6000610dae602283611032565b9150610db982611216565b604082019050919050565b6000610dd1601d83611032565b9150610ddc82611265565b602082019050919050565b6000610df4602683611032565b9150610dff8261128e565b604082019050919050565b6000610e17602583611032565b9150610e22826112dd565b604082019050919050565b6000610e3a602483611032565b9150610e458261132c565b604082019050919050565b6000610e5d602583611032565b9150610e688261137b565b604082019050919050565b6000610e80601f83611032565b9150610e8b826113ca565b602082019050919050565b610e9f816110d7565b82525050565b610eae816110e1565b82525050565b6000602082019050610ec96000830184610d36565b92915050565b60006020820190508181036000830152610ee98184610d45565b905092915050565b60006020820190508181036000830152610f0a81610d7e565b9050919050565b60006020820190508181036000830152610f2a81610da1565b9050919050565b60006020820190508181036000830152610f4a81610dc4565b9050919050565b60006020820190508181036000830152610f6a81610de7565b9050919050565b60006020820190508181036000830152610f8a81610e0a565b9050919050565b60006020820190508181036000830152610faa81610e2d565b9050919050565b60006020820190508181036000830152610fca81610e50565b9050919050565b60006020820190508181036000830152610fea81610e73565b9050919050565b60006020820190506110066000830184610e96565b92915050565b60006020820190506110216000830184610ea5565b92915050565b600081519050919050565b600082825260208201905092915050565b600061104e826110d7565b9150611059836110d7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561108e5761108d611153565b5b828201905092915050565b60006110a4826110b7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561110c5780820151818401526020810190506110f1565b8381111561111b576000848401525b50505050565b6000600282049050600182168061113957607f821691505b6020821081141561114d5761114c611182565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6113fc81611099565b811461140757600080fd5b50565b611413816110d7565b811461141e57600080fd5b5056fea2646970667358221220d4c96329400732e284f624232c8d7228fc90c00ee7b1a48a85080262107815d864736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c613123610081600039600081816105fc0152818161068b01528181610785015281816108140152610bae01526131236000f3fe6080604052600436106100fe5760003560e01c8063715018a611610095578063c4d66de811610064578063c4d66de8146102e4578063dda79b751461030d578063f2fde38b14610338578063f340fa0114610361578063f45346dc1461037d576100fe565b8063715018a6146102505780638c6f037f146102675780638da5cb5b14610290578063ae7a3a6f146102bb576100fe565b80634f1ef286116100d15780634f1ef286146101a15780635131ab59146101bd57806352d1902d146101fa5780635b11259114610225576100fe565b80631b8b921d146101035780631cff79cd1461012c57806329c59b5d1461015c5780633659cfe614610178575b600080fd5b34801561010f57600080fd5b5061012a60048036038101906101259190612183565b6103a6565b005b61014660048036038101906101419190612183565b610412565b6040516101539190612816565b60405180910390f35b61017660048036038101906101719190612183565b610480565b005b34801561018457600080fd5b5061019f600480360381019061019a91906120ce565b6105fa565b005b6101bb60048036038101906101b691906121e3565b610783565b005b3480156101c957600080fd5b506101e460048036038101906101df91906120fb565b6108c0565b6040516101f19190612816565b60405180910390f35b34801561020657600080fd5b5061020f610baa565b60405161021c91906127d7565b60405180910390f35b34801561023157600080fd5b5061023a610c63565b6040516102479190612733565b60405180910390f35b34801561025c57600080fd5b50610265610c89565b005b34801561027357600080fd5b5061028e60048036038101906102899190612292565b610c9d565b005b34801561029c57600080fd5b506102a5610d99565b6040516102b29190612733565b60405180910390f35b3480156102c757600080fd5b506102e260048036038101906102dd91906120ce565b610dc3565b005b3480156102f057600080fd5b5061030b600480360381019061030691906120ce565b610e8f565b005b34801561031957600080fd5b5061032261107e565b60405161032f9190612733565b60405180910390f35b34801561034457600080fd5b5061035f600480360381019061035a91906120ce565b6110a4565b005b61037b600480360381019061037691906120ce565b611128565b005b34801561038957600080fd5b506103a4600480360381019061039f919061223f565b61129c565b005b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde384846040516104059291906127f2565b60405180910390a3505050565b60606000610421858585611392565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f34868660405161046d93929190612a91565b60405180910390a2809150509392505050565b60003414156104bb576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516105039061271e565b60006040518083038185875af1925050503d8060008114610540576040519150601f19603f3d011682016040523d82523d6000602084013e610545565b606091505b50509050600015158115151415610588576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516105ec9493929190612a15565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610689576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068090612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106c8611449565b73ffffffffffffffffffffffffffffffffffffffff161461071e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610715906128b5565b60405180910390fd5b610727816114a0565b61078081600067ffffffffffffffff81111561074657610745612c52565b5b6040519080825280601f01601f1916602001820160405280156107785781602001600182028036833780820191505090505b5060006114ab565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610812576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161080990612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610851611449565b73ffffffffffffffffffffffffffffffffffffffff16146108a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089e906128b5565b60405180910390fd5b6108b0826114a0565b6108bc828260016114ab565b5050565b606060008414156108fd576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6109078686611628565b61093d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016109789291906127ae565b602060405180830381600087803b15801561099257600080fd5b505af11580156109a6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109ca919061231a565b610a00576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610a0d868585611392565b9050610a198787611628565b610a4f576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a8a9190612733565b60206040518083038186803b158015610aa257600080fd5b505afa158015610ab6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ada9190612374565b90506000811115610b3357610b3260c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16828a73ffffffffffffffffffffffffffffffffffffffff166116c09092919063ffffffff16565b5b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610b9493929190612a91565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610c3a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c31906128f5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610c91611746565b610c9b60006117c4565b565b6000841415610cd8576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610d273360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868673ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a486868686604051610d8a9493929190612a15565b60405180910390a35050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e4b576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610ec05750600160008054906101000a900460ff1660ff16105b80610eed5750610ecf30611913565b158015610eec5750600160008054906101000a900460ff1660ff16145b5b610f2c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f2390612935565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610f69576001600060016101000a81548160ff0219169083151502179055505b610f71611936565b610f7961198f565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610fe0576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550801561107a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860016040516110719190612838565b60405180910390a15b5050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110ac611746565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561111c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111390612875565b60405180910390fd5b611125816117c4565b50565b6000341415611163576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516111ab9061271e565b60006040518083038185875af1925050503d80600081146111e8576040519150601f19603f3d011682016040523d82523d6000602084013e6111ed565b606091505b50509050600015158115151415611230576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4346000604051611290929190612a55565b60405180910390a35050565b60008214156112d7576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113263360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848473ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48484604051611385929190612a55565b60405180910390a3505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff163486866040516113bf9291906126ee565b60006040518083038185875af1925050503d80600081146113fc576040519150601f19603f3d011682016040523d82523d6000602084013e611401565b606091505b50915091508161143d576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006114777f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6114a8611746565b50565b6114d77f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6119ea565b60000160009054906101000a900460ff16156114fb576114f6836119f4565b611623565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561154157600080fd5b505afa92505050801561157257506040513d601f19601f8201168201806040525081019061156f9190612347565b60015b6115b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115a890612955565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611616576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160d90612915565b60405180910390fd5b50611622838383611aad565b5b505050565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611666929190612785565b602060405180830381600087803b15801561168057600080fd5b505af1158015611694573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116b8919061231a565b905092915050565b6117418363a9059cbb60e01b84846040516024016116df9291906127ae565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b505050565b61174e611ba0565b73ffffffffffffffffffffffffffffffffffffffff1661176c610d99565b73ffffffffffffffffffffffffffffffffffffffff16146117c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117b990612995565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61190d846323b872dd60e01b8585856040516024016118ab9392919061274e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b50505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611985576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161197c906129d5565b60405180910390fd5b61198d611ba8565b565b600060019054906101000a900460ff166119de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119d5906129d5565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6119fd81611913565b611a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a3390612975565b60405180910390fd5b80611a697f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611ab683611c09565b600082511180611ac35750805b15611ad457611ad28383611c58565b505b505050565b6000611b3b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16611c859092919063ffffffff16565b9050600081511115611b9b5780806020019051810190611b5b919061231a565b611b9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b91906129f5565b60405180910390fd5b5b505050565b600033905090565b600060019054906101000a900460ff16611bf7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611bee906129d5565b60405180910390fd5b611c07611c02611ba0565b6117c4565b565b611c12816119f4565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611c7d83836040518060600160405280602781526020016130c760279139611c9d565b905092915050565b6060611c948484600085611d23565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1685604051611cc79190612707565b600060405180830381855af49150503d8060008114611d02576040519150601f19603f3d011682016040523d82523d6000602084013e611d07565b606091505b5091509150611d1886838387611df0565b925050509392505050565b606082471015611d68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d5f906128d5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611d919190612707565b60006040518083038185875af1925050503d8060008114611dce576040519150601f19603f3d011682016040523d82523d6000602084013e611dd3565b606091505b5091509150611de487838387611e66565b92505050949350505050565b60608315611e5357600083511415611e4b57611e0b85611913565b611e4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e41906129b5565b60405180910390fd5b5b829050611e5e565b611e5d8383611edc565b5b949350505050565b60608315611ec957600083511415611ec157611e8185611f2c565b611ec0576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611eb7906129b5565b60405180910390fd5b5b829050611ed4565b611ed38383611f4f565b5b949350505050565b600082511115611eef5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f239190612853565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600082511115611f625781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f969190612853565b60405180910390fd5b6000611fb2611fad84612ae8565b612ac3565b905082815260208101848484011115611fce57611fcd612c90565b5b611fd9848285612bdf565b509392505050565b600081359050611ff08161306a565b92915050565b60008151905061200581613081565b92915050565b60008151905061201a81613098565b92915050565b60008083601f84011261203657612035612c86565b5b8235905067ffffffffffffffff81111561205357612052612c81565b5b60208301915083600182028301111561206f5761206e612c8b565b5b9250929050565b600082601f83011261208b5761208a612c86565b5b813561209b848260208601611f9f565b91505092915050565b6000813590506120b3816130af565b92915050565b6000815190506120c8816130af565b92915050565b6000602082840312156120e4576120e3612c9a565b5b60006120f284828501611fe1565b91505092915050565b60008060008060006080868803121561211757612116612c9a565b5b600061212588828901611fe1565b955050602061213688828901611fe1565b9450506040612147888289016120a4565b935050606086013567ffffffffffffffff81111561216857612167612c95565b5b61217488828901612020565b92509250509295509295909350565b60008060006040848603121561219c5761219b612c9a565b5b60006121aa86828701611fe1565b935050602084013567ffffffffffffffff8111156121cb576121ca612c95565b5b6121d786828701612020565b92509250509250925092565b600080604083850312156121fa576121f9612c9a565b5b600061220885828601611fe1565b925050602083013567ffffffffffffffff81111561222957612228612c95565b5b61223585828601612076565b9150509250929050565b60008060006060848603121561225857612257612c9a565b5b600061226686828701611fe1565b9350506020612277868287016120a4565b925050604061228886828701611fe1565b9150509250925092565b6000806000806000608086880312156122ae576122ad612c9a565b5b60006122bc88828901611fe1565b95505060206122cd888289016120a4565b94505060406122de88828901611fe1565b935050606086013567ffffffffffffffff8111156122ff576122fe612c95565b5b61230b88828901612020565b92509250509295509295909350565b6000602082840312156123305761232f612c9a565b5b600061233e84828501611ff6565b91505092915050565b60006020828403121561235d5761235c612c9a565b5b600061236b8482850161200b565b91505092915050565b60006020828403121561238a57612389612c9a565b5b6000612398848285016120b9565b91505092915050565b6123aa81612b5c565b82525050565b6123b981612b7a565b82525050565b60006123cb8385612b2f565b93506123d8838584612bdf565b6123e183612c9f565b840190509392505050565b60006123f88385612b40565b9350612405838584612bdf565b82840190509392505050565b600061241c82612b19565b6124268185612b2f565b9350612436818560208601612bee565b61243f81612c9f565b840191505092915050565b600061245582612b19565b61245f8185612b40565b935061246f818560208601612bee565b80840191505092915050565b61248481612bbb565b82525050565b61249381612bcd565b82525050565b60006124a482612b24565b6124ae8185612b4b565b93506124be818560208601612bee565b6124c781612c9f565b840191505092915050565b60006124df602683612b4b565b91506124ea82612cb0565b604082019050919050565b6000612502602c83612b4b565b915061250d82612cff565b604082019050919050565b6000612525602c83612b4b565b915061253082612d4e565b604082019050919050565b6000612548602683612b4b565b915061255382612d9d565b604082019050919050565b600061256b603883612b4b565b915061257682612dec565b604082019050919050565b600061258e602983612b4b565b915061259982612e3b565b604082019050919050565b60006125b1602e83612b4b565b91506125bc82612e8a565b604082019050919050565b60006125d4602e83612b4b565b91506125df82612ed9565b604082019050919050565b60006125f7602d83612b4b565b915061260282612f28565b604082019050919050565b600061261a602083612b4b565b915061262582612f77565b602082019050919050565b600061263d600083612b2f565b915061264882612fa0565b600082019050919050565b6000612660600083612b40565b915061266b82612fa0565b600082019050919050565b6000612683601d83612b4b565b915061268e82612fa3565b602082019050919050565b60006126a6602b83612b4b565b91506126b182612fcc565b604082019050919050565b60006126c9602a83612b4b565b91506126d48261301b565b604082019050919050565b6126e881612ba4565b82525050565b60006126fb8284866123ec565b91508190509392505050565b6000612713828461244a565b915081905092915050565b600061272982612653565b9150819050919050565b600060208201905061274860008301846123a1565b92915050565b600060608201905061276360008301866123a1565b61277060208301856123a1565b61277d60408301846126df565b949350505050565b600060408201905061279a60008301856123a1565b6127a7602083018461247b565b9392505050565b60006040820190506127c360008301856123a1565b6127d060208301846126df565b9392505050565b60006020820190506127ec60008301846123b0565b92915050565b6000602082019050818103600083015261280d8184866123bf565b90509392505050565b600060208201905081810360008301526128308184612411565b905092915050565b600060208201905061284d600083018461248a565b92915050565b6000602082019050818103600083015261286d8184612499565b905092915050565b6000602082019050818103600083015261288e816124d2565b9050919050565b600060208201905081810360008301526128ae816124f5565b9050919050565b600060208201905081810360008301526128ce81612518565b9050919050565b600060208201905081810360008301526128ee8161253b565b9050919050565b6000602082019050818103600083015261290e8161255e565b9050919050565b6000602082019050818103600083015261292e81612581565b9050919050565b6000602082019050818103600083015261294e816125a4565b9050919050565b6000602082019050818103600083015261296e816125c7565b9050919050565b6000602082019050818103600083015261298e816125ea565b9050919050565b600060208201905081810360008301526129ae8161260d565b9050919050565b600060208201905081810360008301526129ce81612676565b9050919050565b600060208201905081810360008301526129ee81612699565b9050919050565b60006020820190508181036000830152612a0e816126bc565b9050919050565b6000606082019050612a2a60008301876126df565b612a3760208301866123a1565b8181036040830152612a4a8184866123bf565b905095945050505050565b6000606082019050612a6a60008301856126df565b612a7760208301846123a1565b8181036040830152612a8881612630565b90509392505050565b6000604082019050612aa660008301866126df565b8181036020830152612ab98184866123bf565b9050949350505050565b6000612acd612ade565b9050612ad98282612c21565b919050565b6000604051905090565b600067ffffffffffffffff821115612b0357612b02612c52565b5b612b0c82612c9f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612b6782612b84565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612bc682612ba4565b9050919050565b6000612bd882612bae565b9050919050565b82818337600083830152505050565b60005b83811015612c0c578082015181840152602081019050612bf1565b83811115612c1b576000848401525b50505050565b612c2a82612c9f565b810181811067ffffffffffffffff82111715612c4957612c48612c52565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61307381612b5c565b811461307e57600080fd5b50565b61308a81612b6e565b811461309557600080fd5b50565b6130a181612b7a565b81146130ac57600080fd5b50565b6130b881612ba4565b81146130c357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220154452ab17b7ec6558ae20cf0777deee4780b8e192489db9d10e2ac9e3d689a364736f6c6343000807003360806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea2646970667358221220c6f7c0f9935341aaaabcabf7504d01bbd38a0606132004742a97e6a200eb432564736f6c63430008070033608060405234801561001057600080fd5b5061108a806100206000396000f3fe60806040526004361061003f5760003560e01c8063357fc5a2146100445780636ed701691461006d578063e04d4f9714610084578063f05b6abf146100a0575b600080fd5b34801561005057600080fd5b5061006b6004803603810190610066919061085a565b6100c9565b005b34801561007957600080fd5b50610082610138565b005b61009e600480360381019061009991906107eb565b610171565b005b3480156100ac57600080fd5b506100c760048036038101906100c29190610733565b6101b5565b005b6100f63382858573ffffffffffffffffffffffffffffffffffffffff166101f7909392919063ffffffff16565b7f2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af603384848460405161012b9493929190610bb0565b60405180910390a1505050565b7fbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0336040516101679190610b0b565b60405180910390a1565b7f1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa33348585856040516101a8959493929190610bf5565b60405180910390a1505050565b7f74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146338484846040516101ea9493929190610b5d565b60405180910390a1505050565b61027a846323b872dd60e01b85858560405160240161021893929190610b26565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610280565b50505050565b60006102e2826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166103479092919063ffffffff16565b9050600081511115610342578080602001905181019061030291906107be565b610341576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161033890610cb1565b60405180910390fd5b5b505050565b6060610356848460008561035f565b90509392505050565b6060824710156103a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161039b90610c71565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516103cd9190610af4565b60006040518083038185875af1925050503d806000811461040a576040519150601f19603f3d011682016040523d82523d6000602084013e61040f565b606091505b50915091506104208783838761042c565b92505050949350505050565b6060831561048f5760008351141561048757610447856104a2565b610486576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161047d90610c91565b60405180910390fd5b5b82905061049a565b61049983836104c5565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156104d85781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050c9190610c4f565b60405180910390fd5b600061052861052384610cf6565b610cd1565b9050808382526020820190508285602086028201111561054b5761054a610f23565b5b60005b8581101561059957813567ffffffffffffffff81111561057157610570610f1e565b5b80860161057e89826106f0565b8552602085019450602084019350505060018101905061054e565b5050509392505050565b60006105b66105b184610d22565b610cd1565b905080838252602082019050828560208602820111156105d9576105d8610f23565b5b60005b8581101561060957816105ef888261071e565b8452602084019350602083019250506001810190506105dc565b5050509392505050565b600061062661062184610d4e565b610cd1565b90508281526020810184848401111561064257610641610f28565b5b61064d848285610e7c565b509392505050565b6000813590506106648161100f565b92915050565b600082601f83011261067f5761067e610f1e565b5b813561068f848260208601610515565b91505092915050565b600082601f8301126106ad576106ac610f1e565b5b81356106bd8482602086016105a3565b91505092915050565b6000813590506106d581611026565b92915050565b6000815190506106ea81611026565b92915050565b600082601f83011261070557610704610f1e565b5b8135610715848260208601610613565b91505092915050565b60008135905061072d8161103d565b92915050565b60008060006060848603121561074c5761074b610f32565b5b600084013567ffffffffffffffff81111561076a57610769610f2d565b5b6107768682870161066a565b935050602084013567ffffffffffffffff81111561079757610796610f2d565b5b6107a386828701610698565b92505060406107b4868287016106c6565b9150509250925092565b6000602082840312156107d4576107d3610f32565b5b60006107e2848285016106db565b91505092915050565b60008060006060848603121561080457610803610f32565b5b600084013567ffffffffffffffff81111561082257610821610f2d565b5b61082e868287016106f0565b935050602061083f8682870161071e565b9250506040610850868287016106c6565b9150509250925092565b60008060006060848603121561087357610872610f32565b5b60006108818682870161071e565b935050602061089286828701610655565b92505060406108a386828701610655565b9150509250925092565b60006108b983836109fb565b905092915050565b60006108cd8383610ad6565b60208301905092915050565b6108e281610e34565b82525050565b60006108f382610d9f565b6108fd8185610de5565b93508360208202850161090f85610d7f565b8060005b8581101561094b578484038952815161092c85826108ad565b945061093783610dcb565b925060208a01995050600181019050610913565b50829750879550505050505092915050565b600061096882610daa565b6109728185610df6565b935061097d83610d8f565b8060005b838110156109ae57815161099588826108c1565b97506109a083610dd8565b925050600181019050610981565b5085935050505092915050565b6109c481610e46565b82525050565b60006109d582610db5565b6109df8185610e07565b93506109ef818560208601610e8b565b80840191505092915050565b6000610a0682610dc0565b610a108185610e12565b9350610a20818560208601610e8b565b610a2981610f37565b840191505092915050565b6000610a3f82610dc0565b610a498185610e23565b9350610a59818560208601610e8b565b610a6281610f37565b840191505092915050565b6000610a7a602683610e23565b9150610a8582610f48565b604082019050919050565b6000610a9d601d83610e23565b9150610aa882610f97565b602082019050919050565b6000610ac0602a83610e23565b9150610acb82610fc0565b604082019050919050565b610adf81610e72565b82525050565b610aee81610e72565b82525050565b6000610b0082846109ca565b915081905092915050565b6000602082019050610b2060008301846108d9565b92915050565b6000606082019050610b3b60008301866108d9565b610b4860208301856108d9565b610b556040830184610ae5565b949350505050565b6000608082019050610b7260008301876108d9565b8181036020830152610b8481866108e8565b90508181036040830152610b98818561095d565b9050610ba760608301846109bb565b95945050505050565b6000608082019050610bc560008301876108d9565b610bd26020830186610ae5565b610bdf60408301856108d9565b610bec60608301846108d9565b95945050505050565b600060a082019050610c0a60008301886108d9565b610c176020830187610ae5565b8181036040830152610c298186610a34565b9050610c386060830185610ae5565b610c4560808301846109bb565b9695505050505050565b60006020820190508181036000830152610c698184610a34565b905092915050565b60006020820190508181036000830152610c8a81610a6d565b9050919050565b60006020820190508181036000830152610caa81610a90565b9050919050565b60006020820190508181036000830152610cca81610ab3565b9050919050565b6000610cdb610cec565b9050610ce78282610ebe565b919050565b6000604051905090565b600067ffffffffffffffff821115610d1157610d10610eef565b5b602082029050602081019050919050565b600067ffffffffffffffff821115610d3d57610d3c610eef565b5b602082029050602081019050919050565b600067ffffffffffffffff821115610d6957610d68610eef565b5b610d7282610f37565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000610e3f82610e52565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610ea9578082015181840152602081019050610e8e565b83811115610eb8576000848401525b50505050565b610ec782610f37565b810181811067ffffffffffffffff82111715610ee657610ee5610eef565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61101881610e34565b811461102357600080fd5b50565b61102f81610e46565b811461103a57600080fd5b50565b61104681610e72565b811461105157600080fd5b5056fea2646970667358221220086a1c9f56ed96506c7198d50cf431a5b03003c16cd4168d2395cdedfc1ac06164736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c612c726200024360003960008181610433015281816104c2015281816105d40152818161066301526107130152612c726000f3fe6080604052600436106100dd5760003560e01c80637993c1e01161007f578063bcf7f32b11610059578063bcf7f32b14610251578063c39aca371461027a578063f2fde38b146102a3578063f45346dc146102cc576100dd565b80637993c1e0146101e65780638129fc1c1461020f5780638da5cb5b14610226576100dd565b80633ce4a5bc116100bb5780633ce4a5bc1461015d5780634f1ef2861461018857806352d1902d146101a4578063715018a6146101cf576100dd565b80630ac7c44c146100e2578063135390f91461010b5780633659cfe614610134575b600080fd5b3480156100ee57600080fd5b5061010960048036038101906101049190611c80565b6102f5565b005b34801561011757600080fd5b50610132600480360381019061012d9190611cfc565b61034c565b005b34801561014057600080fd5b5061015b60048036038101906101569190611b0a565b610431565b005b34801561016957600080fd5b506101726105ba565b60405161017f919061226e565b60405180910390f35b6101a2600480360381019061019d9190611b37565b6105d2565b005b3480156101b057600080fd5b506101b961070f565b6040516101c691906122e9565b60405180910390f35b3480156101db57600080fd5b506101e46107c8565b005b3480156101f257600080fd5b5061020d60048036038101906102089190611d6b565b6107dc565b005b34801561021b57600080fd5b506102246108c7565b005b34801561023257600080fd5b5061023b610a0d565b604051610248919061226e565b60405180910390f35b34801561025d57600080fd5b5061027860048036038101906102739190611e0f565b610a37565b005b34801561028657600080fd5b506102a1600480360381019061029c9190611e0f565b610b2b565b005b3480156102af57600080fd5b506102ca60048036038101906102c59190611b0a565b610d5d565b005b3480156102d857600080fd5b506102f360048036038101906102ee9190611bd3565b610de1565b005b3373ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f84848460405161033f93929190612304565b60405180910390a2505050565b60006103588383610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8585848673ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156103db57600080fd5b505afa1580156103ef573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104139190611ec5565b60405161042394939291906123a0565b60405180910390a250505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156104c0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104b79061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166104ff61128d565b73ffffffffffffffffffffffffffffffffffffffff1614610555576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161054c9061247c565b60405180910390fd5b61055e816112e4565b6105b781600067ffffffffffffffff81111561057d5761057c61282b565b5b6040519080825280601f01601f1916602001820160405280156105af5781602001600182028036833780820191505090505b5060006112ef565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610661576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106589061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106a061128d565b73ffffffffffffffffffffffffffffffffffffffff16146106f6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106ed9061247c565b60405180910390fd5b6106ff826112e4565b61070b828260016112ef565b5050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161461079f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107969061249c565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b6107d061146c565b6107da60006114ea565b565b60006107e88585610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8787848873ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561086b57600080fd5b505afa15801561087f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108a39190611ec5565b88886040516108b79695949392919061233d565b60405180910390a2505050505050565b60008060019054906101000a900460ff161590508080156108f85750600160008054906101000a900460ff1660ff16105b806109255750610907306115b0565b1580156109245750600160008054906101000a900460ff1660ff16145b5b610964576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161095b906124dc565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109a1576001600060016101000a81548160ff0219169083151502179055505b6109a96115d3565b6109b161162c565b8015610a0a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610a0191906123ff565b60405180910390a15b50565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ab0576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610af195949392919061259c565b600060405180830381600087803b158015610b0b57600080fd5b505af1158015610b1f573d6000803e3d6000fd5b50505050505050505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ba4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161480610c1d57503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610c54576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610c8f9291906122c0565b602060405180830381600087803b158015610ca957600080fd5b505af1158015610cbd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ce19190611c26565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610d2395949392919061259c565b600060405180830381600087803b158015610d3d57600080fd5b505af1158015610d51573d6000803e3d6000fd5b50505050505050505050565b610d6561146c565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610dd5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dcc9061243c565b60405180910390fd5b610dde816114ea565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610e5a576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161480610ed357503073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15610f0a576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff166347e7ef2482846040518363ffffffff1660e01b8152600401610f459291906122c0565b602060405180830381600087803b158015610f5f57600080fd5b505af1158015610f73573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f979190611c26565b50505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1663d9eeebed6040518163ffffffff1660e01b8152600401604080518083038186803b158015610fe757600080fd5b505afa158015610ffb573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061101f9190611b93565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b815260040161107493929190612289565b602060405180830381600087803b15801561108e57600080fd5b505af11580156110a2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110c69190611c26565b6110fc576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166323b872dd3330886040518463ffffffff1660e01b815260040161113993929190612289565b602060405180830381600087803b15801561115357600080fd5b505af1158015611167573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061118b9190611c26565b6111c1576040517f4dd9ee8d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166342966c68866040518263ffffffff1660e01b81526004016111fa91906125f1565b602060405180830381600087803b15801561121457600080fd5b505af1158015611228573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061124c9190611c26565b611282576040517f2c77e05c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b809250505092915050565b60006112bb7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6112ec61146c565b50565b61131b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611687565b60000160009054906101000a900460ff161561133f5761133a83611691565b611467565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561138557600080fd5b505afa9250505080156113b657506040513d601f19601f820116820180604052508101906113b39190611c53565b60015b6113f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113ec906124fc565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b811461145a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611451906124bc565b60405180910390fd5b5061146683838361174a565b5b505050565b611474611776565b73ffffffffffffffffffffffffffffffffffffffff16611492610a0d565b73ffffffffffffffffffffffffffffffffffffffff16146114e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114df9061253c565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611622576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116199061257c565b60405180910390fd5b61162a61177e565b565b600060019054906101000a900460ff1661167b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116729061257c565b60405180910390fd5b565b6000819050919050565b6000819050919050565b61169a816115b0565b6116d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116d09061251c565b60405180910390fd5b806117067f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611753836117df565b6000825111806117605750805b156117715761176f838361182e565b505b505050565b600033905090565b600060019054906101000a900460ff166117cd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117c49061257c565b60405180910390fd5b6117dd6117d8611776565b6114ea565b565b6117e881611691565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606118538383604051806060016040528060278152602001612c166027913961185b565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516118859190612257565b600060405180830381855af49150503d80600081146118c0576040519150601f19603f3d011682016040523d82523d6000602084013e6118c5565b606091505b50915091506118d6868383876118e1565b925050509392505050565b606083156119445760008351141561193c576118fc856115b0565b61193b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119329061255c565b60405180910390fd5b5b82905061194f565b61194e8383611957565b5b949350505050565b60008251111561196a5781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161199e919061241a565b60405180910390fd5b60006119ba6119b584612631565b61260c565b9050828152602081018484840111156119d6576119d5612878565b5b6119e18482856127b8565b509392505050565b6000813590506119f881612bb9565b92915050565b600081519050611a0d81612bb9565b92915050565b600081519050611a2281612bd0565b92915050565b600081519050611a3781612be7565b92915050565b60008083601f840112611a5357611a52612864565b5b8235905067ffffffffffffffff811115611a7057611a6f61285f565b5b602083019150836001820283011115611a8c57611a8b612873565b5b9250929050565b600082601f830112611aa857611aa7612864565b5b8135611ab88482602086016119a7565b91505092915050565b600060608284031215611ad757611ad6612869565b5b81905092915050565b600081359050611aef81612bfe565b92915050565b600081519050611b0481612bfe565b92915050565b600060208284031215611b2057611b1f612887565b5b6000611b2e848285016119e9565b91505092915050565b60008060408385031215611b4e57611b4d612887565b5b6000611b5c858286016119e9565b925050602083013567ffffffffffffffff811115611b7d57611b7c61287d565b5b611b8985828601611a93565b9150509250929050565b60008060408385031215611baa57611ba9612887565b5b6000611bb8858286016119fe565b9250506020611bc985828601611af5565b9150509250929050565b600080600060608486031215611bec57611beb612887565b5b6000611bfa868287016119e9565b9350506020611c0b86828701611ae0565b9250506040611c1c868287016119e9565b9150509250925092565b600060208284031215611c3c57611c3b612887565b5b6000611c4a84828501611a13565b91505092915050565b600060208284031215611c6957611c68612887565b5b6000611c7784828501611a28565b91505092915050565b600080600060408486031215611c9957611c98612887565b5b600084013567ffffffffffffffff811115611cb757611cb661287d565b5b611cc386828701611a93565b935050602084013567ffffffffffffffff811115611ce457611ce361287d565b5b611cf086828701611a3d565b92509250509250925092565b600080600060608486031215611d1557611d14612887565b5b600084013567ffffffffffffffff811115611d3357611d3261287d565b5b611d3f86828701611a93565b9350506020611d5086828701611ae0565b9250506040611d61868287016119e9565b9150509250925092565b600080600080600060808688031215611d8757611d86612887565b5b600086013567ffffffffffffffff811115611da557611da461287d565b5b611db188828901611a93565b9550506020611dc288828901611ae0565b9450506040611dd3888289016119e9565b935050606086013567ffffffffffffffff811115611df457611df361287d565b5b611e0088828901611a3d565b92509250509295509295909350565b60008060008060008060a08789031215611e2c57611e2b612887565b5b600087013567ffffffffffffffff811115611e4a57611e4961287d565b5b611e5689828a01611ac1565b9650506020611e6789828a016119e9565b9550506040611e7889828a01611ae0565b9450506060611e8989828a016119e9565b935050608087013567ffffffffffffffff811115611eaa57611ea961287d565b5b611eb689828a01611a3d565b92509250509295509295509295565b600060208284031215611edb57611eda612887565b5b6000611ee984828501611af5565b91505092915050565b611efb81612747565b82525050565b611f0a81612747565b82525050565b611f1981612765565b82525050565b6000611f2b8385612678565b9350611f388385846127b8565b611f418361288c565b840190509392505050565b6000611f588385612689565b9350611f658385846127b8565b611f6e8361288c565b840190509392505050565b6000611f8482612662565b611f8e8185612689565b9350611f9e8185602086016127c7565b611fa78161288c565b840191505092915050565b6000611fbd82612662565b611fc7818561269a565b9350611fd78185602086016127c7565b80840191505092915050565b611fec816127a6565b82525050565b6000611ffd8261266d565b61200781856126a5565b93506120178185602086016127c7565b6120208161288c565b840191505092915050565b60006120386026836126a5565b91506120438261289d565b604082019050919050565b600061205b602c836126a5565b9150612066826128ec565b604082019050919050565b600061207e602c836126a5565b91506120898261293b565b604082019050919050565b60006120a16038836126a5565b91506120ac8261298a565b604082019050919050565b60006120c46029836126a5565b91506120cf826129d9565b604082019050919050565b60006120e7602e836126a5565b91506120f282612a28565b604082019050919050565b600061210a602e836126a5565b915061211582612a77565b604082019050919050565b600061212d602d836126a5565b915061213882612ac6565b604082019050919050565b60006121506020836126a5565b915061215b82612b15565b602082019050919050565b6000612173600083612689565b915061217e82612b3e565b600082019050919050565b6000612196601d836126a5565b91506121a182612b41565b602082019050919050565b60006121b9602b836126a5565b91506121c482612b6a565b604082019050919050565b6000606083016121e260008401846126cd565b85830360008701526121f5838284611f1f565b9250505061220660208401846126b6565b6122136020860182611ef2565b506122216040840184612730565b61222e6040860182612239565b508091505092915050565b6122428161278f565b82525050565b6122518161278f565b82525050565b60006122638284611fb2565b915081905092915050565b60006020820190506122836000830184611f01565b92915050565b600060608201905061229e6000830186611f01565b6122ab6020830185611f01565b6122b86040830184612248565b949350505050565b60006040820190506122d56000830185611f01565b6122e26020830184612248565b9392505050565b60006020820190506122fe6000830184611f10565b92915050565b6000604082019050818103600083015261231e8186611f79565b90508181036020830152612333818486611f4c565b9050949350505050565b600060a08201905081810360008301526123578189611f79565b90506123666020830188612248565b6123736040830187612248565b6123806060830186612248565b8181036080830152612393818486611f4c565b9050979650505050505050565b600060a08201905081810360008301526123ba8187611f79565b90506123c96020830186612248565b6123d66040830185612248565b6123e36060830184612248565b81810360808301526123f481612166565b905095945050505050565b60006020820190506124146000830184611fe3565b92915050565b600060208201905081810360008301526124348184611ff2565b905092915050565b600060208201905081810360008301526124558161202b565b9050919050565b600060208201905081810360008301526124758161204e565b9050919050565b6000602082019050818103600083015261249581612071565b9050919050565b600060208201905081810360008301526124b581612094565b9050919050565b600060208201905081810360008301526124d5816120b7565b9050919050565b600060208201905081810360008301526124f5816120da565b9050919050565b60006020820190508181036000830152612515816120fd565b9050919050565b6000602082019050818103600083015261253581612120565b9050919050565b6000602082019050818103600083015261255581612143565b9050919050565b6000602082019050818103600083015261257581612189565b9050919050565b60006020820190508181036000830152612595816121ac565b9050919050565b600060808201905081810360008301526125b681886121cf565b90506125c56020830187611f01565b6125d26040830186612248565b81810360608301526125e5818486611f4c565b90509695505050505050565b60006020820190506126066000830184612248565b92915050565b6000612616612627565b905061262282826127fa565b919050565b6000604051905090565b600067ffffffffffffffff82111561264c5761264b61282b565b5b6126558261288c565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006126c560208401846119e9565b905092915050565b600080833560016020038436030381126126ea576126e9612882565b5b83810192508235915060208301925067ffffffffffffffff8211156127125761271161285a565b5b6001820236038413156127285761272761286e565b5b509250929050565b600061273f6020840184611ae0565b905092915050565b60006127528261276f565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006127b182612799565b9050919050565b82818337600083830152505050565b60005b838110156127e55780820151818401526020810190506127ca565b838111156127f4576000848401525b50505050565b6128038261288c565b810181811067ffffffffffffffff821117156128225761282161282b565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b612bc281612747565b8114612bcd57600080fd5b50565b612bd981612759565b8114612be457600080fd5b50565b612bf081612765565b8114612bfb57600080fd5b50565b612c078161278f565b8114612c1257600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122015c949adac746922ae292180700af4f4a4ce97a3db9d7b2c84f6c7beb1452aaa64736f6c63430008070033608060405234801561001057600080fd5b50604051610bcd380380610bcd8339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610ab6806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105fd565b61009c565b005b61006a6102af565b6040516100779190610761565b60405180910390f35b61009a6004803603810190610095919061055e565b6102d3565b005b60008383836040516024016100b39392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d92919061077c565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df9190610531565b610215576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161027494939291906107dc565b600060405180830381600087803b15801561028e57600080fd5b505af11580156102a2573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102ea9392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b81526004016103c49291906107a5565b600060405180830381600087803b1580156103de57600080fd5b505af11580156103f2573d6000803e3d6000fd5b505050505050505050565b600061041061040b84610892565b61086d565b90508281526020810184848401111561042c5761042b610a1b565b5b610437848285610974565b509392505050565b600061045261044d846108c3565b61086d565b90508281526020810184848401111561046e5761046d610a1b565b5b610479848285610974565b509392505050565b60008135905061049081610a3b565b92915050565b6000813590506104a581610a52565b92915050565b6000815190506104ba81610a52565b92915050565b600082601f8301126104d5576104d4610a16565b5b81356104e58482602086016103fd565b91505092915050565b600082601f83011261050357610502610a16565b5b813561051384826020860161043f565b91505092915050565b60008135905061052b81610a69565b92915050565b60006020828403121561054757610546610a25565b5b6000610555848285016104ab565b91505092915050565b6000806000806080858703121561057857610577610a25565b5b600085013567ffffffffffffffff81111561059657610595610a20565b5b6105a2878288016104c0565b945050602085013567ffffffffffffffff8111156105c3576105c2610a20565b5b6105cf878288016104ee565b93505060406105e08782880161051c565b92505060606105f187828801610496565b91505092959194509250565b60008060008060008060c0878903121561061a57610619610a25565b5b600087013567ffffffffffffffff81111561063857610637610a20565b5b61064489828a016104c0565b965050602061065589828a0161051c565b955050604061066689828a01610481565b945050606087013567ffffffffffffffff81111561068757610686610a20565b5b61069389828a016104ee565b93505060806106a489828a0161051c565b92505060a06106b589828a01610496565b9150509295509295509295565b6106cb8161092c565b82525050565b6106da8161093e565b82525050565b60006106eb826108f4565b6106f5818561090a565b9350610705818560208601610983565b61070e81610a2a565b840191505092915050565b6000610724826108ff565b61072e818561091b565b935061073e818560208601610983565b61074781610a2a565b840191505092915050565b61075b8161096a565b82525050565b600060208201905061077660008301846106c2565b92915050565b600060408201905061079160008301856106c2565b61079e6020830184610752565b9392505050565b600060408201905081810360008301526107bf81856106e0565b905081810360208301526107d381846106e0565b90509392505050565b600060808201905081810360008301526107f681876106e0565b90506108056020830186610752565b61081260408301856106c2565b818103606083015261082481846106e0565b905095945050505050565b600060608201905081810360008301526108498186610719565b90506108586020830185610752565b61086560408301846106d1565b949350505050565b6000610877610888565b905061088382826109b6565b919050565b6000604051905090565b600067ffffffffffffffff8211156108ad576108ac6109e7565b5b6108b682610a2a565b9050602081019050919050565b600067ffffffffffffffff8211156108de576108dd6109e7565b5b6108e782610a2a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b60006109378261094a565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156109a1578082015181840152602081019050610986565b838111156109b0576000848401525b50505050565b6109bf82610a2a565b810181811067ffffffffffffffff821117156109de576109dd6109e7565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a448161092c565b8114610a4f57600080fd5b50565b610a5b8161093e565b8114610a6657600080fd5b50565b610a728161096a565b8114610a7d57600080fd5b5056fea26469706673582212205b143977db6155828f5d21dccf3e39e1abbc3e6abfa0cfb9b988a47a7ff289c864736f6c6343000807003360806040523480156200001157600080fd5b50604051620010d7380380620010d7833981810160405281019062000037919062000146565b82600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f80699e81136d69cb8367ad52a994e25c722a86da654b561d0c14b61a777e7ac560405160405180910390a1505050620001f5565b6000815190506200014081620001db565b92915050565b600080600060608486031215620001625762000161620001d6565b5b600062000172868287016200012f565b935050602062000185868287016200012f565b925050604062000198868287016200012f565b9150509250925092565b6000620001af82620001b6565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b620001e681620001a2565b8114620001f257600080fd5b50565b610ed280620002056000396000f3fe608060405234801561001057600080fd5b50600436106100a95760003560e01c806397770dff1161007157806397770dff14610166578063a7cb050714610182578063c63585cc1461019e578063d7fd7afb146101ce578063d936a012146101fe578063ee2815ba1461021c576100a9565b80630be15547146100ae5780633c669d55146100de578063513a9c05146100fa578063569541b91461012a578063842da36d14610148575b600080fd5b6100c860048036038101906100c3919061094d565b610238565b6040516100d59190610bce565b60405180910390f35b6100f860048036038101906100f39190610898565b61026b565b005b610114600480360381019061010f919061094d565b6103b8565b6040516101219190610bce565b60405180910390f35b6101326103eb565b60405161013f9190610bce565b60405180910390f35b610150610411565b60405161015d9190610bce565b60405180910390f35b610180600480360381019061017b9190610818565b610437565b005b61019c600480360381019061019791906109ba565b6104d4565b005b6101b860048036038101906101b39190610845565b610528565b6040516101c59190610bce565b60405180910390f35b6101e860048036038101906101e3919061094d565b61059a565b6040516101f59190610c67565b60405180910390f35b6102066105b2565b6040516102139190610bce565b60405180910390f35b6102366004803603810190610231919061097a565b6105d8565b005b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600060405180606001604052806040518060200160405280600081525081526020013373ffffffffffffffffffffffffffffffffffffffff1681526020014681525090508473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb87866040518363ffffffff1660e01b81526004016102ea929190610be9565b602060405180830381600087803b15801561030457600080fd5b505af1158015610318573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061033c9190610920565b508573ffffffffffffffffffffffffffffffffffffffff1663de43156e82878787876040518663ffffffff1660e01b815260040161037e959493929190610c12565b600060405180830381600087803b15801561039857600080fd5b505af11580156103ac573d6000803e3d6000fd5b50505050505050505050565b60026020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fdba79d534382d1a8ae108e4c8ecb27c6ae42ab8b91d44eedf88bd329f3868d5e600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516104c99190610bce565b60405180910390a150565b80600080848152602001908152602001600020819055507f49f492222906ac486c3c1401fa545626df1f0c0e5a77a05597ea2ed66af9850d828260405161051c929190610cab565b60405180910390a15050565b60008060006105378585610667565b9150915085828260405160200161054f929190610b60565b60405160208183030381529060405280519060200120604051602001610576929190610b8c565b6040516020818303038152906040528051906020012060001c925050509392505050565b60006020528060005260406000206000915090505481565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b806001600084815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd1b36d30f6248e97c473b4d1348ca164a4ef6759022f54a58ec200326c39c45d828260405161065b929190610c82565b60405180910390a15050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156106d0576040517fcb1e7cfe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161061070a57828461070d565b83835b8092508193505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561077c576040517f78b507da00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b9250929050565b60008135905061079281610e57565b92915050565b6000815190506107a781610e6e565b92915050565b60008083601f8401126107c3576107c2610dd3565b5b8235905067ffffffffffffffff8111156107e0576107df610dce565b5b6020830191508360018202830111156107fc576107fb610dd8565b5b9250929050565b60008135905061081281610e85565b92915050565b60006020828403121561082e5761082d610de2565b5b600061083c84828501610783565b91505092915050565b60008060006060848603121561085e5761085d610de2565b5b600061086c86828701610783565b935050602061087d86828701610783565b925050604061088e86828701610783565b9150509250925092565b6000806000806000608086880312156108b4576108b3610de2565b5b60006108c288828901610783565b95505060206108d388828901610783565b94505060406108e488828901610803565b935050606086013567ffffffffffffffff81111561090557610904610ddd565b5b610911888289016107ad565b92509250509295509295909350565b60006020828403121561093657610935610de2565b5b600061094484828501610798565b91505092915050565b60006020828403121561096357610962610de2565b5b600061097184828501610803565b91505092915050565b6000806040838503121561099157610990610de2565b5b600061099f85828601610803565b92505060206109b085828601610783565b9150509250929050565b600080604083850312156109d1576109d0610de2565b5b60006109df85828601610803565b92505060206109f085828601610803565b9150509250929050565b610a0381610d0c565b82525050565b610a1281610d0c565b82525050565b610a29610a2482610d0c565b610da0565b82525050565b610a40610a3b82610d2a565b610db2565b82525050565b6000610a528385610cf0565b9350610a5f838584610d5e565b610a6883610de7565b840190509392505050565b6000610a7e82610cd4565b610a888185610cdf565b9350610a98818560208601610d6d565b610aa181610de7565b840191505092915050565b6000610ab9602083610d01565b9150610ac482610e05565b602082019050919050565b6000610adc600183610d01565b9150610ae782610e2e565b600182019050919050565b60006060830160008301518482036000860152610b0f8282610a73565b9150506020830151610b2460208601826109fa565b506040830151610b376040860182610b42565b508091505092915050565b610b4b81610d54565b82525050565b610b5a81610d54565b82525050565b6000610b6c8285610a18565b601482019150610b7c8284610a18565b6014820191508190509392505050565b6000610b9782610acf565b9150610ba38285610a18565b601482019150610bb38284610a2f565b602082019150610bc282610aac565b91508190509392505050565b6000602082019050610be36000830184610a09565b92915050565b6000604082019050610bfe6000830185610a09565b610c0b6020830184610b51565b9392505050565b60006080820190508181036000830152610c2c8188610af2565b9050610c3b6020830187610a09565b610c486040830186610b51565b8181036060830152610c5b818486610a46565b90509695505050505050565b6000602082019050610c7c6000830184610b51565b92915050565b6000604082019050610c976000830185610b51565b610ca46020830184610a09565b9392505050565b6000604082019050610cc06000830185610b51565b610ccd6020830184610b51565b9392505050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b6000610d1782610d34565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610d8b578082015181840152602081019050610d70565b83811115610d9a576000848401525b50505050565b6000610dab82610dbc565b9050919050565b6000819050919050565b6000610dc782610df8565b9050919050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f600082015250565b7fff00000000000000000000000000000000000000000000000000000000000000600082015250565b610e6081610d0c565b8114610e6b57600080fd5b50565b610e7781610d1e565b8114610e8257600080fd5b50565b610e8e81610d54565b8114610e9957600080fd5b5056fea26469706673582212202a32df31a933796903f60b841b0f44768ba91c1035d163fc0f04fe249f5f2e7464736f6c6343000807003360c06040523480156200001157600080fd5b506040516200282d3803806200282d83398181016040528101906200003791906200035b565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614620000b1576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8760079080519060200190620000c9929190620001d1565b508660089080519060200190620000e2929190620001d1565b5085600960006101000a81548160ff021916908360ff16021790555084608081815250508360028111156200011c576200011b620005ae565b5b60a0816002811115620001345762000133620005ae565b5b60f81b8152505082600281905550816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050505050505050620006bf565b828054620001df9062000542565b90600052602060002090601f0160209004810192826200020357600085556200024f565b82601f106200021e57805160ff19168380011785556200024f565b828001600101855582156200024f579182015b828111156200024e57825182559160200191906001019062000231565b5b5090506200025e919062000262565b5090565b5b808211156200027d57600081600090555060010162000263565b5090565b60006200029862000292846200048b565b62000462565b905082815260208101848484011115620002b757620002b662000640565b5b620002c48482856200050c565b509392505050565b600081519050620002dd8162000660565b92915050565b600081519050620002f4816200067a565b92915050565b600082601f8301126200031257620003116200063b565b5b81516200032484826020860162000281565b91505092915050565b6000815190506200033e816200068b565b92915050565b6000815190506200035581620006a5565b92915050565b600080600080600080600080610100898b0312156200037f576200037e6200064a565b5b600089015167ffffffffffffffff811115620003a0576200039f62000645565b5b620003ae8b828c01620002fa565b985050602089015167ffffffffffffffff811115620003d257620003d162000645565b5b620003e08b828c01620002fa565b9750506040620003f38b828c0162000344565b9650506060620004068b828c016200032d565b9550506080620004198b828c01620002e3565b94505060a06200042c8b828c016200032d565b93505060c06200043f8b828c01620002cc565b92505060e0620004528b828c01620002cc565b9150509295985092959890939650565b60006200046e62000481565b90506200047c828262000578565b919050565b6000604051905090565b600067ffffffffffffffff821115620004a957620004a86200060c565b5b620004b4826200064f565b9050602081019050919050565b6000620004ce82620004d5565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b838110156200052c5780820151818401526020810190506200050f565b838111156200053c576000848401525b50505050565b600060028204905060018216806200055b57607f821691505b60208210811415620005725762000571620005dd565b5b50919050565b62000583826200064f565b810181811067ffffffffffffffff82111715620005a557620005a46200060c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b6200066b81620004c1565b81146200067757600080fd5b50565b600381106200068857600080fd5b50565b6200069681620004f5565b8114620006a257600080fd5b50565b620006b081620004ff565b8114620006bc57600080fd5b50565b60805160a05160f81c612137620006f660003960006109580152600081816108a201528181610c250152610d5a01526121376000f3fe608060405234801561001057600080fd5b506004361061014d5760003560e01c806385e1f4d0116100c3578063d9eeebed1161007c578063d9eeebed146103cc578063dd62ed3e146103eb578063e2f535b81461041b578063eddeb12314610439578063f2441b3214610455578063f687d12a146104735761014d565b806385e1f4d0146102f657806395d89b4114610314578063a3413d0314610332578063a9059cbb14610350578063c701262614610380578063c835d7cc146103b05761014d565b8063313ce56711610115578063313ce5671461020c5780633ce4a5bc1461022a57806342966c681461024857806347e7ef24146102785780634d8943bb146102a857806370a08231146102c65761014d565b806306fdde0314610152578063091d278814610170578063095ea7b31461018e57806318160ddd146101be57806323b872dd146101dc575b600080fd5b61015a61048f565b6040516101679190611cad565b60405180910390f35b610178610521565b6040516101859190611ccf565b60405180910390f35b6101a860048036038101906101a3919061196e565b610527565b6040516101b59190611bfb565b60405180910390f35b6101c6610545565b6040516101d39190611ccf565b60405180910390f35b6101f660048036038101906101f1919061191b565b61054f565b6040516102039190611bfb565b60405180910390f35b610214610647565b6040516102219190611cea565b60405180910390f35b61023261065e565b60405161023f9190611b80565b60405180910390f35b610262600480360381019061025d9190611a37565b610676565b60405161026f9190611bfb565b60405180910390f35b610292600480360381019061028d919061196e565b61068b565b60405161029f9190611bfb565b60405180910390f35b6102b0610851565b6040516102bd9190611ccf565b60405180910390f35b6102e060048036038101906102db9190611881565b610857565b6040516102ed9190611ccf565b60405180910390f35b6102fe6108a0565b60405161030b9190611ccf565b60405180910390f35b61031c6108c4565b6040516103299190611cad565b60405180910390f35b61033a610956565b6040516103479190611c92565b60405180910390f35b61036a6004803603810190610365919061196e565b61097a565b6040516103779190611bfb565b60405180910390f35b61039a600480360381019061039591906119db565b610998565b6040516103a79190611bfb565b60405180910390f35b6103ca60048036038101906103c59190611881565b610aee565b005b6103d4610be1565b6040516103e2929190611bd2565b60405180910390f35b610405600480360381019061040091906118db565b610e4e565b6040516104129190611ccf565b60405180910390f35b610423610ed5565b6040516104309190611b80565b60405180910390f35b610453600480360381019061044e9190611a37565b610efb565b005b61045d610fb5565b60405161046a9190611b80565b60405180910390f35b61048d60048036038101906104889190611a37565b610fd9565b005b60606007805461049e90611f33565b80601f01602080910402602001604051908101604052809291908181526020018280546104ca90611f33565b80156105175780601f106104ec57610100808354040283529160200191610517565b820191906000526020600020905b8154815290600101906020018083116104fa57829003601f168201915b5050505050905090565b60025481565b600061053b610534611093565b848461109b565b6001905092915050565b6000600654905090565b600061055c848484611254565b6000600560008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006105a7611093565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205490508281101561061e576040517f10bad14700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61063b8561062a611093565b85846106369190611e43565b61109b565b60019150509392505050565b6000600960009054906101000a900460ff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b600061068233836114b0565b60019050919050565b600073735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614158015610729575060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614155b80156107835750600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614155b156107ba576040517fddb5de5e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6107c48383611668565b8273ffffffffffffffffffffffffffffffffffffffff167f67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab373735b14bb79463307aacbed86daf3322b1e6226ab6040516020016108219190611b65565b6040516020818303038152906040528460405161083f929190611c16565b60405180910390a26001905092915050565b60035481565b6000600460008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b7f000000000000000000000000000000000000000000000000000000000000000081565b6060600880546108d390611f33565b80601f01602080910402602001604051908101604052809291908181526020018280546108ff90611f33565b801561094c5780601f106109215761010080835404028352916020019161094c565b820191906000526020600020905b81548152906001019060200180831161092f57829003601f168201915b5050505050905090565b7f000000000000000000000000000000000000000000000000000000000000000081565b600061098e610987611093565b8484611254565b6001905092915050565b60008060006109a5610be1565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b81526004016109fa93929190611b9b565b602060405180830381600087803b158015610a1457600080fd5b505af1158015610a28573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a4c91906119ae565b610a82576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610a8c33856114b0565b3373ffffffffffffffffffffffffffffffffffffffff167f9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955868684600354604051610ada9493929190611c46565b60405180910390a260019250505092915050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610b67576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae81604051610bd69190611b80565b60405180910390a150565b60008060008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630be155477f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610c609190611ccf565b60206040518083038186803b158015610c7857600080fd5b505afa158015610c8c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cb091906118ae565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610d19576040517f78fff39600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d7fd7afb7f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610d959190611ccf565b60206040518083038186803b158015610dad57600080fd5b505afa158015610dc1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610de59190611a64565b90506000811415610e22576040517fe661aed000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060035460025483610e359190611de9565b610e3f9190611d93565b90508281945094505050509091565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610f74576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806003819055507fef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f81604051610faa9190611ccf565b60405180910390a150565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611052576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806002819055507fff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a816040516110889190611ccf565b60405180910390a150565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611102576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611169576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516112479190611ccf565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156112bb576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611322576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156113a0576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816113ac9190611e43565b600460008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825461143e9190611d93565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516114a29190611ccf565b60405180910390a350505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611517576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611595576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816115a19190611e43565b600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600660008282546115f69190611e43565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161165b9190611ccf565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116cf576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600660008282546116e19190611d93565b9250508190555080600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546117379190611d93565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161179c9190611ccf565b60405180910390a35050565b60006117bb6117b684611d2a565b611d05565b9050828152602081018484840111156117d7576117d661207b565b5b6117e2848285611ef1565b509392505050565b6000813590506117f9816120bc565b92915050565b60008151905061180e816120bc565b92915050565b600081519050611823816120d3565b92915050565b600082601f83011261183e5761183d612076565b5b813561184e8482602086016117a8565b91505092915050565b600081359050611866816120ea565b92915050565b60008151905061187b816120ea565b92915050565b60006020828403121561189757611896612085565b5b60006118a5848285016117ea565b91505092915050565b6000602082840312156118c4576118c3612085565b5b60006118d2848285016117ff565b91505092915050565b600080604083850312156118f2576118f1612085565b5b6000611900858286016117ea565b9250506020611911858286016117ea565b9150509250929050565b60008060006060848603121561193457611933612085565b5b6000611942868287016117ea565b9350506020611953868287016117ea565b925050604061196486828701611857565b9150509250925092565b6000806040838503121561198557611984612085565b5b6000611993858286016117ea565b92505060206119a485828601611857565b9150509250929050565b6000602082840312156119c4576119c3612085565b5b60006119d284828501611814565b91505092915050565b600080604083850312156119f2576119f1612085565b5b600083013567ffffffffffffffff811115611a1057611a0f612080565b5b611a1c85828601611829565b9250506020611a2d85828601611857565b9150509250929050565b600060208284031215611a4d57611a4c612085565b5b6000611a5b84828501611857565b91505092915050565b600060208284031215611a7a57611a79612085565b5b6000611a888482850161186c565b91505092915050565b611a9a81611e77565b82525050565b611ab1611aac82611e77565b611f96565b82525050565b611ac081611e89565b82525050565b6000611ad182611d5b565b611adb8185611d71565b9350611aeb818560208601611f00565b611af48161208a565b840191505092915050565b611b0881611edf565b82525050565b6000611b1982611d66565b611b238185611d82565b9350611b33818560208601611f00565b611b3c8161208a565b840191505092915050565b611b5081611ec8565b82525050565b611b5f81611ed2565b82525050565b6000611b718284611aa0565b60148201915081905092915050565b6000602082019050611b956000830184611a91565b92915050565b6000606082019050611bb06000830186611a91565b611bbd6020830185611a91565b611bca6040830184611b47565b949350505050565b6000604082019050611be76000830185611a91565b611bf46020830184611b47565b9392505050565b6000602082019050611c106000830184611ab7565b92915050565b60006040820190508181036000830152611c308185611ac6565b9050611c3f6020830184611b47565b9392505050565b60006080820190508181036000830152611c608187611ac6565b9050611c6f6020830186611b47565b611c7c6040830185611b47565b611c896060830184611b47565b95945050505050565b6000602082019050611ca76000830184611aff565b92915050565b60006020820190508181036000830152611cc78184611b0e565b905092915050565b6000602082019050611ce46000830184611b47565b92915050565b6000602082019050611cff6000830184611b56565b92915050565b6000611d0f611d20565b9050611d1b8282611f65565b919050565b6000604051905090565b600067ffffffffffffffff821115611d4557611d44612047565b5b611d4e8261208a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b6000611d9e82611ec8565b9150611da983611ec8565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115611dde57611ddd611fba565b5b828201905092915050565b6000611df482611ec8565b9150611dff83611ec8565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615611e3857611e37611fba565b5b828202905092915050565b6000611e4e82611ec8565b9150611e5983611ec8565b925082821015611e6c57611e6b611fba565b5b828203905092915050565b6000611e8282611ea8565b9050919050565b60008115159050919050565b6000819050611ea3826120a8565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000611eea82611e95565b9050919050565b82818337600083830152505050565b60005b83811015611f1e578082015181840152602081019050611f03565b83811115611f2d576000848401525b50505050565b60006002820490506001821680611f4b57607f821691505b60208210811415611f5f57611f5e612018565b5b50919050565b611f6e8261208a565b810181811067ffffffffffffffff82111715611f8d57611f8c612047565b5b80604052505050565b6000611fa182611fa8565b9050919050565b6000611fb38261209b565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b600381106120b9576120b8611fe9565b5b50565b6120c581611e77565b81146120d057600080fd5b50565b6120dc81611e89565b81146120e757600080fd5b50565b6120f381611ec8565b81146120fe57600080fd5b5056fea26469706673582212204256743d8281ef8d828896d1bab08cb03656cd913941f2ab189ea466016eead564736f6c63430008070033a264697066735822122061a51f9afd0e3be660d02e15aa3ec2c11dcb8b25643f9be51d4c39275da350c064736f6c63430008070033"; + +type GatewayIntegrationTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayIntegrationTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayIntegrationTest__factory extends ContractFactory { + constructor(...args: GatewayIntegrationTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayIntegrationTest { + return super.attach(address) as GatewayIntegrationTest; + } + override connect(signer: Signer): GatewayIntegrationTest__factory { + return super.connect(signer) as GatewayIntegrationTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayIntegrationTestInterface { + return new utils.Interface(_abi) as GatewayIntegrationTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayIntegrationTest { + return new Contract( + address, + _abi, + signerOrProvider + ) as GatewayIntegrationTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts b/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts new file mode 100644 index 00000000..c9d4b01a --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayIntegration.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { GatewayIntegrationTest__factory } from "./GatewayIntegrationTest__factory"; diff --git a/typechain-types/factories/contracts/prototypes/test/index.ts b/typechain-types/factories/contracts/prototypes/test/index.ts new file mode 100644 index 00000000..57d14c51 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export * as gatewayEvmTSol from "./GatewayEVM.t.sol"; +export * as gatewayIntegrationTSol from "./GatewayIntegration.t.sol"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index a8e69e9e..669609d2 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -487,7 +487,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index fafcf4e0..54e177ea 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts index 389b7ace..051c4305 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -1,7 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as zrc20NewSol from "./ZRC20New.sol"; export * as interfacesSol from "./interfaces.sol"; export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; export { SenderZEVM__factory } from "./SenderZEVM__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts new file mode 100644 index 00000000..1ad08445 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts @@ -0,0 +1,94 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVMEvents, + IGatewayZEVMEventsInterface, +} from "../../../../../contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Withdrawal", + type: "event", + }, +] as const; + +export class IGatewayZEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMEventsInterface { + return new utils.Interface(_abi) as IGatewayZEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts index 6c9d09b5..aa11647e 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -2,3 +2,4 @@ /* tslint:disable */ /* eslint-disable */ export { IGatewayZEVM__factory } from "./IGatewayZEVM__factory"; +export { IGatewayZEVMEvents__factory } from "./IGatewayZEVMEvents__factory"; diff --git a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts index a25f7578..5cdfe45d 100644 --- a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts +++ b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts @@ -429,7 +429,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts b/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts index 10c29867..bd26c05d 100644 --- a/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts +++ b/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts @@ -236,7 +236,7 @@ const _abi = [ { indexed: false, internalType: "uint256", - name: "gasfee", + name: "gasFee", type: "uint256", }, { @@ -626,7 +626,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ZRC20ConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20Errors__factory.ts b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20Errors__factory.ts new file mode 100644 index 00000000..b50ce364 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20Errors__factory.ts @@ -0,0 +1,66 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ZRC20Errors, + ZRC20ErrorsInterface, +} from "../../../../contracts/zevm/ZRC20New.sol/ZRC20Errors"; + +const _abi = [ + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InvalidSender", + type: "error", + }, + { + inputs: [], + name: "LowAllowance", + type: "error", + }, + { + inputs: [], + name: "LowBalance", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + inputs: [], + name: "ZeroGasCoin", + type: "error", + }, + { + inputs: [], + name: "ZeroGasPrice", + type: "error", + }, +] as const; + +export class ZRC20Errors__factory { + static readonly abi = _abi; + static createInterface(): ZRC20ErrorsInterface { + return new utils.Interface(_abi) as ZRC20ErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZRC20Errors { + return new Contract(address, _abi, signerOrProvider) as ZRC20Errors; + } +} diff --git a/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts new file mode 100644 index 00000000..2e4cf605 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts @@ -0,0 +1,730 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { + Signer, + utils, + Contract, + ContractFactory, + BigNumberish, + Overrides, +} from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZRC20New, + ZRC20NewInterface, +} from "../../../../contracts/zevm/ZRC20New.sol/ZRC20New"; + +const _abi = [ + { + inputs: [ + { + internalType: "string", + name: "name_", + type: "string", + }, + { + internalType: "string", + name: "symbol_", + type: "string", + }, + { + internalType: "uint8", + name: "decimals_", + type: "uint8", + }, + { + internalType: "uint256", + name: "chainid_", + type: "uint256", + }, + { + internalType: "enum CoinType", + name: "coinType_", + type: "uint8", + }, + { + internalType: "uint256", + name: "gasLimit_", + type: "uint256", + }, + { + internalType: "address", + name: "systemContractAddress_", + type: "address", + }, + { + internalType: "address", + name: "gatewayContractAddress_", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InvalidSender", + type: "error", + }, + { + inputs: [], + name: "LowAllowance", + type: "error", + }, + { + inputs: [], + name: "LowBalance", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + inputs: [], + name: "ZeroGasCoin", + type: "error", + }, + { + inputs: [], + name: "ZeroGasPrice", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "from", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "gasLimit", + type: "uint256", + }, + ], + name: "UpdatedGasLimit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "UpdatedProtocolFlatFee", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "systemContract", + type: "address", + }, + ], + name: "UpdatedSystemContract", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasFee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + inputs: [], + name: "CHAIN_ID", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "COIN_TYPE", + outputs: [ + { + internalType: "enum CoinType", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "FUNGIBLE_MODULE_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "GAS_LIMIT", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "GATEWAY_CONTRACT_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "PROTOCOL_FLAT_FEE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "SYSTEM_CONTRACT_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burn", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "deposit", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "gasLimit", + type: "uint256", + }, + ], + name: "updateGasLimit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "updateProtocolFlatFee", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + ], + name: "updateSystemContractAddress", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "withdrawGasFee", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZRC20NewConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZRC20NewConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZRC20New__factory extends ContractFactory { + constructor(...args: ZRC20NewConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + chainid_: PromiseOrValue, + coinType_: PromiseOrValue, + gasLimit_: PromiseOrValue, + systemContractAddress_: PromiseOrValue, + gatewayContractAddress_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + name_, + symbol_, + decimals_, + chainid_, + coinType_, + gasLimit_, + systemContractAddress_, + gatewayContractAddress_, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + name_: PromiseOrValue, + symbol_: PromiseOrValue, + decimals_: PromiseOrValue, + chainid_: PromiseOrValue, + coinType_: PromiseOrValue, + gasLimit_: PromiseOrValue, + systemContractAddress_: PromiseOrValue, + gatewayContractAddress_: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction( + name_, + symbol_, + decimals_, + chainid_, + coinType_, + gasLimit_, + systemContractAddress_, + gatewayContractAddress_, + overrides || {} + ); + } + override attach(address: string): ZRC20New { + return super.attach(address) as ZRC20New; + } + override connect(signer: Signer): ZRC20New__factory { + return super.connect(signer) as ZRC20New__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZRC20NewInterface { + return new utils.Interface(_abi) as ZRC20NewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZRC20New { + return new Contract(address, _abi, signerOrProvider) as ZRC20New; + } +} diff --git a/typechain-types/factories/contracts/zevm/ZRC20New.sol/index.ts b/typechain-types/factories/contracts/zevm/ZRC20New.sol/index.ts new file mode 100644 index 00000000..7e4b987c --- /dev/null +++ b/typechain-types/factories/contracts/zevm/ZRC20New.sol/index.ts @@ -0,0 +1,5 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { ZRC20Errors__factory } from "./ZRC20Errors__factory"; +export { ZRC20New__factory } from "./ZRC20New__factory"; diff --git a/typechain-types/factories/contracts/zevm/index.ts b/typechain-types/factories/contracts/zevm/index.ts index 1d36cb0b..0d3bcbac 100644 --- a/typechain-types/factories/contracts/zevm/index.ts +++ b/typechain-types/factories/contracts/zevm/index.ts @@ -1,10 +1,10 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as interfacesSol from "./Interfaces.sol"; export * as systemContractSol from "./SystemContract.sol"; export * as wzetaSol from "./WZETA.sol"; export * as zrc20Sol from "./ZRC20.sol"; +export * as zrc20NewSol from "./ZRC20New.sol"; export * as zetaConnectorZevmSol from "./ZetaConnectorZEVM.sol"; export * as interfaces from "./interfaces"; export * as testing from "./testing"; diff --git a/typechain-types/factories/contracts/zevm/interfaces/ISystem__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/ISystem__factory.ts new file mode 100644 index 00000000..2bbf9c00 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/ISystem__factory.ts @@ -0,0 +1,122 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ISystem, + ISystemInterface, +} from "../../../../contracts/zevm/interfaces/ISystem"; + +const _abi = [ + { + inputs: [], + name: "FUNGIBLE_MODULE_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasCoinZRC20ByChainId", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasPriceByChainId", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasZetaPoolByChainId", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "uniswapv2FactoryAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "wZetaContractAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class ISystem__factory { + static readonly abi = _abi; + static createInterface(): ISystemInterface { + return new utils.Interface(_abi) as ISystemInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ISystem { + return new Contract(address, _abi, signerOrProvider) as ISystem; + } +} diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ISystem__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ISystem__factory.ts new file mode 100644 index 00000000..d99738ae --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ISystem__factory.ts @@ -0,0 +1,122 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ISystem, + ISystemInterface, +} from "../../../../../contracts/zevm/interfaces/IZRC20.sol/ISystem"; + +const _abi = [ + { + inputs: [], + name: "FUNGIBLE_MODULE_ADDRESS", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasCoinZRC20ByChainId", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasPriceByChainId", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + name: "gasZetaPoolByChainId", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "uniswapv2FactoryAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "wZetaContractAddress", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class ISystem__factory { + static readonly abi = _abi; + static createInterface(): ISystemInterface { + return new utils.Interface(_abi) as ISystemInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ISystem { + return new Contract(address, _abi, signerOrProvider) as ISystem; + } +} diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata__factory.ts new file mode 100644 index 00000000..55896920 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata__factory.ts @@ -0,0 +1,296 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IZRC20Metadata, + IZRC20MetadataInterface, +} from "../../../../../contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata"; + +const _abi = [ + { + inputs: [], + name: "PROTOCOL_FLAT_FEE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burn", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "decimals", + outputs: [ + { + internalType: "uint8", + name: "", + type: "uint8", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "deposit", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "name", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "symbol", + outputs: [ + { + internalType: "string", + name: "", + type: "string", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "withdrawGasFee", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class IZRC20Metadata__factory { + static readonly abi = _abi; + static createInterface(): IZRC20MetadataInterface { + return new utils.Interface(_abi) as IZRC20MetadataInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IZRC20Metadata { + return new Contract(address, _abi, signerOrProvider) as IZRC20Metadata; + } +} diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20__factory.ts new file mode 100644 index 00000000..34658aa1 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20__factory.ts @@ -0,0 +1,254 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IZRC20, + IZRC20Interface, +} from "../../../../../contracts/zevm/interfaces/IZRC20.sol/IZRC20"; + +const _abi = [ + { + inputs: [], + name: "PROTOCOL_FLAT_FEE", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burn", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "deposit", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "address", + name: "recipient", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "withdrawGasFee", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class IZRC20__factory { + static readonly abi = _abi; + static createInterface(): IZRC20Interface { + return new utils.Interface(_abi) as IZRC20Interface; + } + static connect(address: string, signerOrProvider: Signer | Provider): IZRC20 { + return new Contract(address, _abi, signerOrProvider) as IZRC20; + } +} diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events__factory.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events__factory.ts new file mode 100644 index 00000000..44ec83ce --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events__factory.ts @@ -0,0 +1,177 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ZRC20Events, + ZRC20EventsInterface, +} from "../../../../../contracts/zevm/interfaces/IZRC20.sol/ZRC20Events"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "from", + type: "bytes", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "gasLimit", + type: "uint256", + }, + ], + name: "UpdatedGasLimit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "UpdatedProtocolFlatFee", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "systemContract", + type: "address", + }, + ], + name: "UpdatedSystemContract", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasFee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + ], + name: "Withdrawal", + type: "event", + }, +] as const; + +export class ZRC20Events__factory { + static readonly abi = _abi; + static createInterface(): ZRC20EventsInterface { + return new utils.Interface(_abi) as ZRC20EventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZRC20Events { + return new Contract(address, _abi, signerOrProvider) as ZRC20Events; + } +} diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts new file mode 100644 index 00000000..7d1b6770 --- /dev/null +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts @@ -0,0 +1,7 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { ISystem__factory } from "./ISystem__factory"; +export { IZRC20__factory } from "./IZRC20__factory"; +export { IZRC20Metadata__factory } from "./IZRC20Metadata__factory"; +export { ZRC20Events__factory } from "./ZRC20Events__factory"; diff --git a/typechain-types/factories/contracts/zevm/interfaces/index.ts b/typechain-types/factories/contracts/zevm/interfaces/index.ts index 0b7ab835..4089cf24 100644 --- a/typechain-types/factories/contracts/zevm/interfaces/index.ts +++ b/typechain-types/factories/contracts/zevm/interfaces/index.ts @@ -2,7 +2,8 @@ /* tslint:disable */ /* eslint-disable */ export * as iwzetaSol from "./IWZETA.sol"; +export * as izrc20Sol from "./IZRC20.sol"; +export { ISystem__factory } from "./ISystem__factory"; export { IUniswapV2Router01__factory } from "./IUniswapV2Router01__factory"; export { IUniswapV2Router02__factory } from "./IUniswapV2Router02__factory"; -export { IZRC20__factory } from "./IZRC20__factory"; export { ZContract__factory } from "./ZContract__factory"; diff --git a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts index 73252fb7..0620b88e 100644 --- a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts +++ b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts @@ -332,7 +332,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractMockConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 60f76a34..f48868c6 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -340,10 +340,6 @@ declare module "hardhat/types/runtime" { name: "GatewayEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "GatewayEVMTest", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "GatewayEVMUpgradeTest", signerOrOptions?: ethers.Signer | FactoryOptions @@ -372,6 +368,14 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "GatewayEVMTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "GatewayIntegrationTest", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -380,6 +384,10 @@ declare module "hardhat/types/runtime" { name: "IGatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IGatewayZEVMEvents", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "SenderZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -388,26 +396,10 @@ declare module "hardhat/types/runtime" { name: "TestZContract", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "ZRC20Errors", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; - getContractFactory( - name: "ZRC20New", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "ISystem", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "IZRC20", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; - getContractFactory( - name: "IZRC20Metadata", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "IUniswapV2Router01", signerOrOptions?: ethers.Signer | FactoryOptions @@ -420,10 +412,22 @@ declare module "hardhat/types/runtime" { name: "IWETH9", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ISystem", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "IZRC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IZRC20Metadata", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ZRC20Events", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ZContract", signerOrOptions?: ethers.Signer | FactoryOptions @@ -464,6 +468,14 @@ declare module "hardhat/types/runtime" { name: "ZRC20Errors", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ZRC20Errors", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ZRC20New", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "IERC165", signerOrOptions?: ethers.Signer | FactoryOptions @@ -939,11 +951,6 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "GatewayEVMTest", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "GatewayEVMUpgradeTest", address: string, @@ -979,6 +986,16 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "GatewayEVMTest", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "GatewayIntegrationTest", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayZEVM", address: string, @@ -989,6 +1006,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IGatewayZEVMEvents", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "SenderZEVM", address: string, @@ -999,31 +1021,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "ZRC20Errors", - address: string, - signer?: ethers.Signer - ): Promise; - getContractAt( - name: "ZRC20New", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "ISystem", address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "IZRC20", - address: string, - signer?: ethers.Signer - ): Promise; - getContractAt( - name: "IZRC20Metadata", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "IUniswapV2Router01", address: string, @@ -1039,11 +1041,26 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ISystem", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "IZRC20", address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IZRC20Metadata", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZRC20Events", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ZContract", address: string, @@ -1094,6 +1111,16 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ZRC20Errors", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZRC20New", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "IERC165", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 208fd59c..24211c0f 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -162,8 +162,6 @@ export type { ERC20CustodyNew } from "./contracts/prototypes/evm/ERC20CustodyNew export { ERC20CustodyNew__factory } from "./factories/contracts/prototypes/evm/ERC20CustodyNew__factory"; export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; -export type { GatewayEVMTest } from "./contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest"; -export { GatewayEVMTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVM.t.sol/GatewayEVMTest__factory"; export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; @@ -178,26 +176,30 @@ export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; +export type { GatewayEVMTest } from "./contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest"; +export { GatewayEVMTest__factory } from "./factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory"; +export type { GatewayIntegrationTest } from "./contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest"; +export { GatewayIntegrationTest__factory } from "./factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; +export type { IGatewayZEVMEvents } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents"; +export { IGatewayZEVMEvents__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory"; export type { SenderZEVM } from "./contracts/prototypes/zevm/SenderZEVM"; export { SenderZEVM__factory } from "./factories/contracts/prototypes/zevm/SenderZEVM__factory"; export type { TestZContract } from "./contracts/prototypes/zevm/TestZContract"; export { TestZContract__factory } from "./factories/contracts/prototypes/zevm/TestZContract__factory"; -export type { ZRC20Errors } from "./contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors"; -export { ZRC20Errors__factory } from "./factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20Errors__factory"; -export type { ZRC20New } from "./contracts/prototypes/zevm/ZRC20New.sol/ZRC20New"; -export { ZRC20New__factory } from "./factories/contracts/prototypes/zevm/ZRC20New.sol/ZRC20New__factory"; -export type { ISystem } from "./contracts/zevm/Interfaces.sol/ISystem"; -export { ISystem__factory } from "./factories/contracts/zevm/Interfaces.sol/ISystem__factory"; -export type { IZRC20 } from "./contracts/zevm/Interfaces.sol/IZRC20"; -export { IZRC20__factory } from "./factories/contracts/zevm/Interfaces.sol/IZRC20__factory"; -export type { IZRC20Metadata } from "./contracts/zevm/Interfaces.sol/IZRC20Metadata"; -export { IZRC20Metadata__factory } from "./factories/contracts/zevm/Interfaces.sol/IZRC20Metadata__factory"; +export type { ISystem } from "./contracts/zevm/interfaces/ISystem"; +export { ISystem__factory } from "./factories/contracts/zevm/interfaces/ISystem__factory"; export type { IWETH9 } from "./contracts/zevm/interfaces/IWZETA.sol/IWETH9"; export { IWETH9__factory } from "./factories/contracts/zevm/interfaces/IWZETA.sol/IWETH9__factory"; +export type { IZRC20 } from "./contracts/zevm/interfaces/IZRC20.sol/IZRC20"; +export { IZRC20__factory } from "./factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20__factory"; +export type { IZRC20Metadata } from "./contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata"; +export { IZRC20Metadata__factory } from "./factories/contracts/zevm/interfaces/IZRC20.sol/IZRC20Metadata__factory"; +export type { ZRC20Events } from "./contracts/zevm/interfaces/IZRC20.sol/ZRC20Events"; +export { ZRC20Events__factory } from "./factories/contracts/zevm/interfaces/IZRC20.sol/ZRC20Events__factory"; export type { ZContract } from "./contracts/zevm/interfaces/ZContract"; export { ZContract__factory } from "./factories/contracts/zevm/interfaces/ZContract__factory"; export type { SystemContract } from "./contracts/zevm/SystemContract.sol/SystemContract"; @@ -210,6 +212,10 @@ export type { ZetaConnectorZEVM } from "./contracts/zevm/ZetaConnectorZEVM.sol/Z export { ZetaConnectorZEVM__factory } from "./factories/contracts/zevm/ZetaConnectorZEVM.sol/ZetaConnectorZEVM__factory"; export type { ZRC20 } from "./contracts/zevm/ZRC20.sol/ZRC20"; export { ZRC20__factory } from "./factories/contracts/zevm/ZRC20.sol/ZRC20__factory"; +export type { ZRC20Errors } from "./contracts/zevm/ZRC20.sol/ZRC20Errors"; +export { ZRC20Errors__factory } from "./factories/contracts/zevm/ZRC20.sol/ZRC20Errors__factory"; +export type { ZRC20New } from "./contracts/zevm/ZRC20New.sol/ZRC20New"; +export { ZRC20New__factory } from "./factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory"; export type { IERC165 } from "./forge-std/interfaces/IERC165"; export { IERC165__factory } from "./factories/forge-std/interfaces/IERC165__factory"; export type { IERC721 } from "./forge-std/interfaces/IERC721.sol/IERC721"; From 4613a1592b59e06a3081213c38b41ba7bebaf2e6 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 01:50:24 +0200 Subject: [PATCH 62/86] cleanup --- contracts/prototypes/test/GatewayEVM.t.sol | 1 - ...Integration.t.sol => GatewayEVMZEVM.t.sol} | 5 +- contracts/prototypes/zevm/GatewayZEVM.sol | 10 +- contracts/prototypes/zevm/interfaces.sol | 10 + .../test/gatewayevm.t.sol/gatewayevmtest.go | 2 +- .../gatewayevmzevmtest.go} | 1608 ++++++++--------- .../zevm/gatewayzevm.sol/gatewayzevm.go | 2 +- .../zevm/interfaces.sol/igatewayzevmerrors.go | 181 ++ .../zevm/senderzevm.sol/senderzevm.go | 2 +- .../GatewayEVMZEVMTest.ts | 1078 +++++++++++ .../test/GatewayEVMZEVM.t.sol/index.ts | 4 + .../contracts/prototypes/test/index.ts | 4 +- .../zevm/interfaces.sol/IGatewayZEVMErrors.ts | 56 + .../prototypes/zevm/interfaces.sol/index.ts | 1 + .../GatewayEVMTest__factory.ts | 2 +- .../GatewayEVMZEVMTest__factory.ts | 1013 +++++++++++ .../test/GatewayEVMZEVM.t.sol/index.ts | 4 + .../contracts/prototypes/test/index.ts | 2 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 2 +- .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../IGatewayZEVMErrors__factory.ts | 61 + .../prototypes/zevm/interfaces.sol/index.ts | 1 + typechain-types/hardhat.d.ts | 17 +- typechain-types/index.ts | 6 +- 24 files changed, 3242 insertions(+), 832 deletions(-) rename contracts/prototypes/test/{GatewayIntegration.t.sol => GatewayEVMZEVM.t.sol} (96%) rename pkg/contracts/prototypes/test/{gatewayintegration.t.sol/gatewayintegrationtest.go => gatewayevmzevm.t.sol/gatewayevmzevmtest.go} (73%) create mode 100644 pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go create mode 100644 typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts create mode 100644 typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts diff --git a/contracts/prototypes/test/GatewayEVM.t.sol b/contracts/prototypes/test/GatewayEVM.t.sol index 6d5430de..474e0589 100644 --- a/contracts/prototypes/test/GatewayEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVM.t.sol @@ -54,7 +54,6 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver vm.expectCall(address(receiver), value, data); vm.expectEmit(true, true, true, true, address(gateway)); emit Executed(address(receiver), value, data); - // TODO: can not check event emitted in Receiver? gateway.execute{value: value}(address(receiver), data); } diff --git a/contracts/prototypes/test/GatewayIntegration.t.sol b/contracts/prototypes/test/GatewayEVMZEVM.t.sol similarity index 96% rename from contracts/prototypes/test/GatewayIntegration.t.sol rename to contracts/prototypes/test/GatewayEVMZEVM.t.sol index a69278f8..8aa94b7b 100644 --- a/contracts/prototypes/test/GatewayIntegration.t.sol +++ b/contracts/prototypes/test/GatewayEVMZEVM.t.sol @@ -21,7 +21,7 @@ import "../evm/interfaces.sol"; import "../zevm/interfaces.sol"; import "forge-std/console.sol"; -contract GatewayIntegrationTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGatewayZEVMEvents, IReceiverEVMEvents { +contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGatewayZEVMEvents, IGatewayZEVMErrors, IReceiverEVMEvents { // evm using SafeERC20 for IERC20; @@ -63,10 +63,9 @@ contract GatewayIntegrationTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, I receiverEVM = new ReceiverEVM(); // zevm - // Impersonate the fungible module account gatewayZEVM = new GatewayZEVM(); - senderZEVM = new SenderZEVM(address(gatewayZEVM)); + // Impersonate the fungible module account address fungibleModuleAddress = address(0x735b14BB79463307AAcBED86DAf3322B1e6226aB); vm.startPrank(fungibleModuleAddress); systemContract = new SystemContractMock(address(0), address(0), address(0)); diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 0730a864..274b440e 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -10,17 +10,9 @@ import "./interfaces.sol"; // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances -contract GatewayZEVM is IGatewayZEVMEvents, Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, OwnableUpgradeable, UUPSUpgradeable { address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; - error WithdrawalFailed(); - error InsufficientZRC20Amount(); - error ZRC20BurnFailed(); - error ZRC20TransferFailed(); - error GasFeeTransferFailed(); - error CallerIsNotFungibleModule(); - error InvalidTarget(); - /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/interfaces.sol index 60088a5c..bc4be8aa 100644 --- a/contracts/prototypes/zevm/interfaces.sol +++ b/contracts/prototypes/zevm/interfaces.sol @@ -36,4 +36,14 @@ interface IGatewayZEVM { interface IGatewayZEVMEvents { event Call(address indexed sender, bytes receiver, bytes message); event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); +} + +interface IGatewayZEVMErrors { + error WithdrawalFailed(); + error InsufficientZRC20Amount(); + error ZRC20BurnFailed(); + error ZRC20TransferFailed(); + error GasFeeTransferFailed(); + error CallerIsNotFungibleModule(); + error InvalidTarget(); } \ No newline at end of file diff --git a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go index 5a7938c4..a0763b85 100644 --- a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. var GatewayEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x60806040526001600c60006101000a81548160ff0219169083151502179055506001601f60006101000a81548160ff02191690831515021790555034801561004657600080fd5b5061807d806100566000396000f3fe60806040523480156200001157600080fd5b5060043610620001005760003560e01c8063916a17c61162000099578063ba414fa6116200006f578063ba414fa61462000243578063e20c9f711462000265578063fa7626d41462000287578063fe7bdbb214620002a95762000100565b8063916a17c614620001dd578063b0464fdc14620001ff578063b5508aa914620002215762000100565b80633e5e3c2311620000db5780633e5e3c2314620001555780633f7286f4146200017757806366d9a9a0146200019957806385226c8114620001bb5762000100565b80630a9254e414620001055780631ed7831c14620001115780632ade38801462000133575b600080fd5b6200010f620002b5565b005b6200011b620007f5565b6040516200012a919062001fc1565b60405180910390f35b6200013d62000885565b6040516200014c91906200202d565b60405180910390f35b6200015f62000a1f565b6040516200016e919062001fc1565b60405180910390f35b6200018162000aaf565b60405162000190919062001fc1565b60405180910390f35b620001a362000b3f565b604051620001b2919062002009565b60405180910390f35b620001c562000cd6565b604051620001d4919062001fe5565b60405180910390f35b620001e762000db9565b604051620001f6919062002051565b60405180910390f35b6200020962000f0c565b60405162000218919062002051565b60405180910390f35b6200022b6200105f565b6040516200023a919062001fe5565b60405180910390f35b6200024d62001142565b6040516200025c919062002075565b60405180910390f35b6200026f62001275565b6040516200027e919062001fc1565b60405180910390f35b6200029162001305565b604051620002a0919062002075565b60405180910390f35b620002b362001318565b005b30602360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550611234602460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550615678602560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200038a90620016d2565b620003959062002133565b604051809103906000f080158015620003b2573d6000803e3d6000fd5b50602260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200040190620016e0565b604051809103906000f0801580156200041e573d6000803e3d6000fd5b50601f60016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516200049090620016ee565b6200049c919062001ea5565b604051809103906000f080158015620004b9573d6000803e3d6000fd5b50602160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c4d66de8602560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b815260040162000579919062001ea5565b600060405180830381600087803b1580156200059457600080fd5b505af1158015620005a9573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ae7a3a6f602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200062c919062001ea5565b600060405180830381600087803b1580156200064757600080fd5b505af11580156200065c573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b8152600401620006e492919062001f23565b600060405180830381600087803b158015620006ff57600080fd5b505af115801562000714573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166207a1206040518363ffffffff1660e01b81526004016200079c92919062001f50565b602060405180830381600087803b158015620007b757600080fd5b505af1158015620007cc573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620007f29190620017a8565b50565b606060168054806020026020016040519081016040528092919081815260200182805480156200087b57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000830575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020016000905b8282101562000a1657838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020016000905b82821015620009fe5783829060005260206000200180546200096a906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000998906200248b565b8015620009e95780601f10620009bd57610100808354040283529160200191620009e9565b820191906000526020600020905b815481529060010190602001808311620009cb57829003601f168201915b50505050508152602001906001019062000948565b505050508152505081526020019060010190620008a9565b50505050905090565b6060601880548060200260200160405190810160405280929190818152602001828054801562000aa557602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000a5a575b5050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801562000b3557602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000aea575b5050505050905090565b6060601b805480602002602001604051908101604052809291908181526020016000905b8282101562000ccd578382906000526020600020906002020160405180604001604052908160008201805462000b99906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000bc7906200248b565b801562000c185780601f1062000bec5761010080835404028352916020019162000c18565b820191906000526020600020905b81548152906001019060200180831162000bfa57829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801562000cb457602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000c605790505b5050505050815250508152602001906001019062000b63565b50505050905090565b6060601a805480602002602001604051908101604052809291908181526020016000905b8282101562000db057838290600052602060002001805462000d1c906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000d4a906200248b565b801562000d9b5780601f1062000d6f5761010080835404028352916020019162000d9b565b820191906000526020600020905b81548152906001019060200180831162000d7d57829003601f168201915b50505050508152602001906001019062000cfa565b50505050905090565b6060601d805480602002602001604051908101604052809291908181526020016000905b8282101562000f0357838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020016001820180548060200260200160405190810160405280929190818152602001828054801562000eea57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000e965790505b5050505050815250508152602001906001019062000ddd565b50505050905090565b6060601c805480602002602001604051908101604052809291908181526020016000905b828210156200105657838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600182018054806020026020016040519081016040528092919081815260200182805480156200103d57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000fe95790505b5050505050815250508152602001906001019062000f30565b50505050905090565b60606019805480602002602001604051908101604052809291908181526020016000905b8282101562001139578382906000526020600020018054620010a5906200248b565b80601f0160208091040260200160405190810160405280929190818152602001828054620010d3906200248b565b8015620011245780601f10620010f85761010080835404028352916020019162001124565b820191906000526020600020905b8154815290600101906020018083116200110657829003601f168201915b50505050508152602001906001019062001083565b50505050905090565b6000600860009054906101000a900460ff16156200117257600860009054906101000a900460ff16905062001272565b6000801b7f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663667f9d707f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c7f6661696c656400000000000000000000000000000000000000000000000000006040518363ffffffff1660e01b81526004016200121992919062001ec2565b60206040518083038186803b1580156200123257600080fd5b505afa15801562001247573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200126d9190620017da565b141590505b90565b60606015805480602002602001604051908101604052809291908181526020018280548015620012fb57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620012b0575b5050505050905090565b601f60009054906101000a900460ff1681565b60006040518060400160405280600f81526020017f48656c6c6f2c20466f756e64727921000000000000000000000000000000000081525090506000602a90506000600190506000670de0b6b3a7640000905060008484846040516024016200138493929190620020ef565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663f30c7ba3602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684846040518463ffffffff1660e01b8152600401620014879392919062001f7d565b600060405180830381600087803b158015620014a257600080fd5b505af1158015620014b7573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b81526004016200154595949392919062002092565b600060405180830381600087803b1580156200156057600080fd5b505af115801562001575573d6000803e3d6000fd5b50505050602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f8383604051620015e59291906200216a565b60405180910390a2601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16631cff79cd83602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b81526004016200166f92919062001eef565b6000604051808303818588803b1580156200168957600080fd5b505af11580156200169e573d6000803e3d6000fd5b50505050506040513d6000823e3d601f19601f82011682018060405250810190620016ca91906200180c565b505050505050565b611813806200260183390190565b6131a48062003e1483390190565b6110908062006fb883390190565b6000620017136200170d84620021c7565b6200219e565b9050828152602081018484840111156200173257620017316200255a565b5b6200173f84828562002455565b509392505050565b6000815190506200175881620025cc565b92915050565b6000815190506200176f81620025e6565b92915050565b600082601f8301126200178d576200178c62002555565b5b81516200179f848260208601620016fc565b91505092915050565b600060208284031215620017c157620017c062002564565b5b6000620017d18482850162001747565b91505092915050565b600060208284031215620017f357620017f262002564565b5b600062001803848285016200175e565b91505092915050565b60006020828403121562001825576200182462002564565b5b600082015167ffffffffffffffff8111156200184657620018456200255f565b5b620018548482850162001775565b91505092915050565b60006200186b8383620018e9565b60208301905092915050565b600062001885838362001c86565b60208301905092915050565b60006200189f838362001cfa565b905092915050565b6000620018b5838362001dca565b905092915050565b6000620018cb838362001e12565b905092915050565b6000620018e1838362001e53565b905092915050565b620018f481620023ad565b82525050565b6200190581620023ad565b82525050565b600062001918826200225d565b62001924818562002303565b93506200193183620021fd565b8060005b83811015620019685781516200194c88826200185d565b97506200195983620022b5565b92505060018101905062001935565b5085935050505092915050565b6000620019828262002268565b6200198e818562002314565b93506200199b836200220d565b8060005b83811015620019d2578151620019b6888262001877565b9750620019c383620022c2565b9250506001810190506200199f565b5085935050505092915050565b6000620019ec8262002273565b620019f8818562002325565b93508360208202850162001a0c856200221d565b8060005b8581101562001a4e578484038952815162001a2c858262001891565b945062001a3983620022cf565b925060208a0199505060018101905062001a10565b50829750879550505050505092915050565b600062001a6d8262002273565b62001a79818562002336565b93508360208202850162001a8d856200221d565b8060005b8581101562001acf578484038952815162001aad858262001891565b945062001aba83620022cf565b925060208a0199505060018101905062001a91565b50829750879550505050505092915050565b600062001aee826200227e565b62001afa818562002347565b93508360208202850162001b0e856200222d565b8060005b8581101562001b50578484038952815162001b2e8582620018a7565b945062001b3b83620022dc565b925060208a0199505060018101905062001b12565b50829750879550505050505092915050565b600062001b6f8262002289565b62001b7b818562002358565b93508360208202850162001b8f856200223d565b8060005b8581101562001bd1578484038952815162001baf8582620018bd565b945062001bbc83620022e9565b925060208a0199505060018101905062001b93565b50829750879550505050505092915050565b600062001bf08262002294565b62001bfc818562002369565b93508360208202850162001c10856200224d565b8060005b8581101562001c52578484038952815162001c308582620018d3565b945062001c3d83620022f6565b925060208a0199505060018101905062001c14565b50829750879550505050505092915050565b62001c6f81620023c1565b82525050565b62001c8081620023cd565b82525050565b62001c9181620023d7565b82525050565b600062001ca4826200229f565b62001cb081856200237a565b935062001cc281856020860162002455565b62001ccd8162002569565b840191505092915050565b62001ce3816200242d565b82525050565b62001cf48162002441565b82525050565b600062001d0782620022aa565b62001d1381856200238b565b935062001d2581856020860162002455565b62001d308162002569565b840191505092915050565b600062001d4882620022aa565b62001d5481856200239c565b935062001d6681856020860162002455565b62001d718162002569565b840191505092915050565b600062001d8b6003836200239c565b915062001d98826200257a565b602082019050919050565b600062001db26004836200239c565b915062001dbf82620025a3565b602082019050919050565b6000604083016000830151848203600086015262001de9828262001cfa565b9150506020830151848203602086015262001e05828262001975565b9150508091505092915050565b600060408301600083015162001e2c6000860182620018e9565b506020830151848203602086015262001e468282620019df565b9150508091505092915050565b600060408301600083015162001e6d6000860182620018e9565b506020830151848203602086015262001e87828262001975565b9150508091505092915050565b62001e9f8162002423565b82525050565b600060208201905062001ebc6000830184620018fa565b92915050565b600060408201905062001ed96000830185620018fa565b62001ee8602083018462001c75565b9392505050565b600060408201905062001f066000830185620018fa565b818103602083015262001f1a818462001c97565b90509392505050565b600060408201905062001f3a6000830185620018fa565b62001f49602083018462001cd8565b9392505050565b600060408201905062001f676000830185620018fa565b62001f76602083018462001ce9565b9392505050565b600060608201905062001f946000830186620018fa565b62001fa3602083018562001e94565b818103604083015262001fb7818462001c97565b9050949350505050565b6000602082019050818103600083015262001fdd81846200190b565b905092915050565b6000602082019050818103600083015262002001818462001a60565b905092915050565b6000602082019050818103600083015262002025818462001ae1565b905092915050565b6000602082019050818103600083015262002049818462001b62565b905092915050565b600060208201905081810360008301526200206d818462001be3565b905092915050565b60006020820190506200208c600083018462001c64565b92915050565b600060a082019050620020a9600083018862001c64565b620020b8602083018762001c64565b620020c7604083018662001c64565b620020d6606083018562001c64565b620020e56080830184620018fa565b9695505050505050565b600060608201905081810360008301526200210b818662001d3b565b90506200211c602083018562001e94565b6200212b604083018462001c64565b949350505050565b600060408201905081810360008301526200214e8162001da3565b90508181036020830152620021638162001d7c565b9050919050565b600060408201905062002181600083018562001e94565b818103602083015262002195818462001c97565b90509392505050565b6000620021aa620021bd565b9050620021b88282620024c1565b919050565b6000604051905090565b600067ffffffffffffffff821115620021e557620021e462002526565b5b620021f08262002569565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000620023ba8262002403565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006200243a8262002423565b9050919050565b60006200244e8262002423565b9050919050565b60005b838110156200247557808201518184015260208101905062002458565b8381111562002485576000848401525b50505050565b60006002820490506001821680620024a457607f821691505b60208210811415620024bb57620024ba620024f7565b5b50919050565b620024cc8262002569565b810181811067ffffffffffffffff82111715620024ee57620024ed62002526565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f54544b0000000000000000000000000000000000000000000000000000000000600082015250565b7f7465737400000000000000000000000000000000000000000000000000000000600082015250565b620025d781620023c1565b8114620025e357600080fd5b50565b620025f181620023cd565b8114620025fd57600080fd5b5056fe60806040523480156200001157600080fd5b5060405162001813380380620018138339818101604052810190620000379190620001a3565b818181600390805190602001906200005192919062000075565b5080600490805190602001906200006a92919062000075565b5050505050620003ac565b8280546200008390620002bd565b90600052602060002090601f016020900481019282620000a75760008555620000f3565b82601f10620000c257805160ff1916838001178555620000f3565b82800160010185558215620000f3579182015b82811115620000f2578251825591602001919060010190620000d5565b5b50905062000102919062000106565b5090565b5b808211156200012157600081600090555060010162000107565b5090565b60006200013c620001368462000251565b62000228565b9050828152602081018484840111156200015b576200015a6200038c565b5b6200016884828562000287565b509392505050565b600082601f83011262000188576200018762000387565b5b81516200019a84826020860162000125565b91505092915050565b60008060408385031215620001bd57620001bc62000396565b5b600083015167ffffffffffffffff811115620001de57620001dd62000391565b5b620001ec8582860162000170565b925050602083015167ffffffffffffffff81111562000210576200020f62000391565b5b6200021e8582860162000170565b9150509250929050565b60006200023462000247565b9050620002428282620002f3565b919050565b6000604051905090565b600067ffffffffffffffff8211156200026f576200026e62000358565b5b6200027a826200039b565b9050602081019050919050565b60005b83811015620002a75780820151818401526020810190506200028a565b83811115620002b7576000848401525b50505050565b60006002820490506001821680620002d657607f821691505b60208210811415620002ed57620002ec62000329565b5b50919050565b620002fe826200039b565b810181811067ffffffffffffffff8211171562000320576200031f62000358565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b61145780620003bc6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c806340c10f191161007157806340c10f19146101a357806370a08231146101bf57806395d89b41146101ef578063a457c2d71461020d578063a9059cbb1461023d578063dd62ed3e1461026d576100b4565b806306fdde03146100b9578063095ea7b3146100d757806318160ddd1461010757806323b872dd14610125578063313ce567146101555780633950935114610173575b600080fd5b6100c161029d565b6040516100ce9190610ecf565b60405180910390f35b6100f160048036038101906100ec9190610cf6565b61032f565b6040516100fe9190610eb4565b60405180910390f35b61010f610352565b60405161011c9190610ff1565b60405180910390f35b61013f600480360381019061013a9190610ca3565b61035c565b60405161014c9190610eb4565b60405180910390f35b61015d61038b565b60405161016a919061100c565b60405180910390f35b61018d60048036038101906101889190610cf6565b610394565b60405161019a9190610eb4565b60405180910390f35b6101bd60048036038101906101b89190610cf6565b6103cb565b005b6101d960048036038101906101d49190610c36565b6103d9565b6040516101e69190610ff1565b60405180910390f35b6101f7610421565b6040516102049190610ecf565b60405180910390f35b61022760048036038101906102229190610cf6565b6104b3565b6040516102349190610eb4565b60405180910390f35b61025760048036038101906102529190610cf6565b61052a565b6040516102649190610eb4565b60405180910390f35b61028760048036038101906102829190610c63565b61054d565b6040516102949190610ff1565b60405180910390f35b6060600380546102ac90611121565b80601f01602080910402602001604051908101604052809291908181526020018280546102d890611121565b80156103255780601f106102fa57610100808354040283529160200191610325565b820191906000526020600020905b81548152906001019060200180831161030857829003601f168201915b5050505050905090565b60008061033a6105d4565b90506103478185856105dc565b600191505092915050565b6000600254905090565b6000806103676105d4565b90506103748582856107a7565b61037f858585610833565b60019150509392505050565b60006012905090565b60008061039f6105d4565b90506103c08185856103b1858961054d565b6103bb9190611043565b6105dc565b600191505092915050565b6103d58282610aab565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60606004805461043090611121565b80601f016020809104026020016040519081016040528092919081815260200182805461045c90611121565b80156104a95780601f1061047e576101008083540402835291602001916104a9565b820191906000526020600020905b81548152906001019060200180831161048c57829003601f168201915b5050505050905090565b6000806104be6105d4565b905060006104cc828661054d565b905083811015610511576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050890610fb1565b60405180910390fd5b61051e82868684036105dc565b60019250505092915050565b6000806105356105d4565b9050610542818585610833565b600191505092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610f91565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156106bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106b390610f11565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161079a9190610ff1565b60405180910390a3505050565b60006107b3848461054d565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461082d578181101561081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690610f31565b60405180910390fd5b61082c84848484036105dc565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156108a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089a90610f71565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610913576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090a90610ef1565b60405180910390fd5b61091e838383610c02565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156109a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099b90610f51565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a929190610ff1565b60405180910390a3610aa5848484610c07565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610b1b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1290610fd1565b60405180910390fd5b610b2760008383610c02565b8060026000828254610b399190611043565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051610bea9190610ff1565b60405180910390a3610bfe60008383610c07565b5050565b505050565b505050565b600081359050610c1b816113f3565b92915050565b600081359050610c308161140a565b92915050565b600060208284031215610c4c57610c4b6111b1565b5b6000610c5a84828501610c0c565b91505092915050565b60008060408385031215610c7a57610c796111b1565b5b6000610c8885828601610c0c565b9250506020610c9985828601610c0c565b9150509250929050565b600080600060608486031215610cbc57610cbb6111b1565b5b6000610cca86828701610c0c565b9350506020610cdb86828701610c0c565b9250506040610cec86828701610c21565b9150509250925092565b60008060408385031215610d0d57610d0c6111b1565b5b6000610d1b85828601610c0c565b9250506020610d2c85828601610c21565b9150509250929050565b610d3f816110ab565b82525050565b6000610d5082611027565b610d5a8185611032565b9350610d6a8185602086016110ee565b610d73816111b6565b840191505092915050565b6000610d8b602383611032565b9150610d96826111c7565b604082019050919050565b6000610dae602283611032565b9150610db982611216565b604082019050919050565b6000610dd1601d83611032565b9150610ddc82611265565b602082019050919050565b6000610df4602683611032565b9150610dff8261128e565b604082019050919050565b6000610e17602583611032565b9150610e22826112dd565b604082019050919050565b6000610e3a602483611032565b9150610e458261132c565b604082019050919050565b6000610e5d602583611032565b9150610e688261137b565b604082019050919050565b6000610e80601f83611032565b9150610e8b826113ca565b602082019050919050565b610e9f816110d7565b82525050565b610eae816110e1565b82525050565b6000602082019050610ec96000830184610d36565b92915050565b60006020820190508181036000830152610ee98184610d45565b905092915050565b60006020820190508181036000830152610f0a81610d7e565b9050919050565b60006020820190508181036000830152610f2a81610da1565b9050919050565b60006020820190508181036000830152610f4a81610dc4565b9050919050565b60006020820190508181036000830152610f6a81610de7565b9050919050565b60006020820190508181036000830152610f8a81610e0a565b9050919050565b60006020820190508181036000830152610faa81610e2d565b9050919050565b60006020820190508181036000830152610fca81610e50565b9050919050565b60006020820190508181036000830152610fea81610e73565b9050919050565b60006020820190506110066000830184610e96565b92915050565b60006020820190506110216000830184610ea5565b92915050565b600081519050919050565b600082825260208201905092915050565b600061104e826110d7565b9150611059836110d7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561108e5761108d611153565b5b828201905092915050565b60006110a4826110b7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561110c5780820151818401526020810190506110f1565b8381111561111b576000848401525b50505050565b6000600282049050600182168061113957607f821691505b6020821081141561114d5761114c611182565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6113fc81611099565b811461140757600080fd5b50565b611413816110d7565b811461141e57600080fd5b5056fea2646970667358221220d4c96329400732e284f624232c8d7228fc90c00ee7b1a48a85080262107815d864736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c613123610081600039600081816105fc0152818161068b01528181610785015281816108140152610bae01526131236000f3fe6080604052600436106100fe5760003560e01c8063715018a611610095578063c4d66de811610064578063c4d66de8146102e4578063dda79b751461030d578063f2fde38b14610338578063f340fa0114610361578063f45346dc1461037d576100fe565b8063715018a6146102505780638c6f037f146102675780638da5cb5b14610290578063ae7a3a6f146102bb576100fe565b80634f1ef286116100d15780634f1ef286146101a15780635131ab59146101bd57806352d1902d146101fa5780635b11259114610225576100fe565b80631b8b921d146101035780631cff79cd1461012c57806329c59b5d1461015c5780633659cfe614610178575b600080fd5b34801561010f57600080fd5b5061012a60048036038101906101259190612183565b6103a6565b005b61014660048036038101906101419190612183565b610412565b6040516101539190612816565b60405180910390f35b61017660048036038101906101719190612183565b610480565b005b34801561018457600080fd5b5061019f600480360381019061019a91906120ce565b6105fa565b005b6101bb60048036038101906101b691906121e3565b610783565b005b3480156101c957600080fd5b506101e460048036038101906101df91906120fb565b6108c0565b6040516101f19190612816565b60405180910390f35b34801561020657600080fd5b5061020f610baa565b60405161021c91906127d7565b60405180910390f35b34801561023157600080fd5b5061023a610c63565b6040516102479190612733565b60405180910390f35b34801561025c57600080fd5b50610265610c89565b005b34801561027357600080fd5b5061028e60048036038101906102899190612292565b610c9d565b005b34801561029c57600080fd5b506102a5610d99565b6040516102b29190612733565b60405180910390f35b3480156102c757600080fd5b506102e260048036038101906102dd91906120ce565b610dc3565b005b3480156102f057600080fd5b5061030b600480360381019061030691906120ce565b610e8f565b005b34801561031957600080fd5b5061032261107e565b60405161032f9190612733565b60405180910390f35b34801561034457600080fd5b5061035f600480360381019061035a91906120ce565b6110a4565b005b61037b600480360381019061037691906120ce565b611128565b005b34801561038957600080fd5b506103a4600480360381019061039f919061223f565b61129c565b005b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde384846040516104059291906127f2565b60405180910390a3505050565b60606000610421858585611392565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f34868660405161046d93929190612a91565b60405180910390a2809150509392505050565b60003414156104bb576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516105039061271e565b60006040518083038185875af1925050503d8060008114610540576040519150601f19603f3d011682016040523d82523d6000602084013e610545565b606091505b50509050600015158115151415610588576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516105ec9493929190612a15565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610689576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068090612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106c8611449565b73ffffffffffffffffffffffffffffffffffffffff161461071e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610715906128b5565b60405180910390fd5b610727816114a0565b61078081600067ffffffffffffffff81111561074657610745612c52565b5b6040519080825280601f01601f1916602001820160405280156107785781602001600182028036833780820191505090505b5060006114ab565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610812576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161080990612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610851611449565b73ffffffffffffffffffffffffffffffffffffffff16146108a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089e906128b5565b60405180910390fd5b6108b0826114a0565b6108bc828260016114ab565b5050565b606060008414156108fd576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6109078686611628565b61093d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016109789291906127ae565b602060405180830381600087803b15801561099257600080fd5b505af11580156109a6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109ca919061231a565b610a00576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610a0d868585611392565b9050610a198787611628565b610a4f576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a8a9190612733565b60206040518083038186803b158015610aa257600080fd5b505afa158015610ab6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ada9190612374565b90506000811115610b3357610b3260c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16828a73ffffffffffffffffffffffffffffffffffffffff166116c09092919063ffffffff16565b5b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610b9493929190612a91565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610c3a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c31906128f5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610c91611746565b610c9b60006117c4565b565b6000841415610cd8576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610d273360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868673ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a486868686604051610d8a9493929190612a15565b60405180910390a35050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e4b576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610ec05750600160008054906101000a900460ff1660ff16105b80610eed5750610ecf30611913565b158015610eec5750600160008054906101000a900460ff1660ff16145b5b610f2c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f2390612935565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610f69576001600060016101000a81548160ff0219169083151502179055505b610f71611936565b610f7961198f565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610fe0576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550801561107a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860016040516110719190612838565b60405180910390a15b5050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110ac611746565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561111c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111390612875565b60405180910390fd5b611125816117c4565b50565b6000341415611163576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516111ab9061271e565b60006040518083038185875af1925050503d80600081146111e8576040519150601f19603f3d011682016040523d82523d6000602084013e6111ed565b606091505b50509050600015158115151415611230576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4346000604051611290929190612a55565b60405180910390a35050565b60008214156112d7576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113263360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848473ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48484604051611385929190612a55565b60405180910390a3505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff163486866040516113bf9291906126ee565b60006040518083038185875af1925050503d80600081146113fc576040519150601f19603f3d011682016040523d82523d6000602084013e611401565b606091505b50915091508161143d576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006114777f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6114a8611746565b50565b6114d77f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6119ea565b60000160009054906101000a900460ff16156114fb576114f6836119f4565b611623565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561154157600080fd5b505afa92505050801561157257506040513d601f19601f8201168201806040525081019061156f9190612347565b60015b6115b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115a890612955565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611616576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160d90612915565b60405180910390fd5b50611622838383611aad565b5b505050565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611666929190612785565b602060405180830381600087803b15801561168057600080fd5b505af1158015611694573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116b8919061231a565b905092915050565b6117418363a9059cbb60e01b84846040516024016116df9291906127ae565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b505050565b61174e611ba0565b73ffffffffffffffffffffffffffffffffffffffff1661176c610d99565b73ffffffffffffffffffffffffffffffffffffffff16146117c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117b990612995565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61190d846323b872dd60e01b8585856040516024016118ab9392919061274e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b50505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611985576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161197c906129d5565b60405180910390fd5b61198d611ba8565b565b600060019054906101000a900460ff166119de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119d5906129d5565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6119fd81611913565b611a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a3390612975565b60405180910390fd5b80611a697f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611ab683611c09565b600082511180611ac35750805b15611ad457611ad28383611c58565b505b505050565b6000611b3b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16611c859092919063ffffffff16565b9050600081511115611b9b5780806020019051810190611b5b919061231a565b611b9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b91906129f5565b60405180910390fd5b5b505050565b600033905090565b600060019054906101000a900460ff16611bf7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611bee906129d5565b60405180910390fd5b611c07611c02611ba0565b6117c4565b565b611c12816119f4565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611c7d83836040518060600160405280602781526020016130c760279139611c9d565b905092915050565b6060611c948484600085611d23565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1685604051611cc79190612707565b600060405180830381855af49150503d8060008114611d02576040519150601f19603f3d011682016040523d82523d6000602084013e611d07565b606091505b5091509150611d1886838387611df0565b925050509392505050565b606082471015611d68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d5f906128d5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611d919190612707565b60006040518083038185875af1925050503d8060008114611dce576040519150601f19603f3d011682016040523d82523d6000602084013e611dd3565b606091505b5091509150611de487838387611e66565b92505050949350505050565b60608315611e5357600083511415611e4b57611e0b85611913565b611e4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e41906129b5565b60405180910390fd5b5b829050611e5e565b611e5d8383611edc565b5b949350505050565b60608315611ec957600083511415611ec157611e8185611f2c565b611ec0576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611eb7906129b5565b60405180910390fd5b5b829050611ed4565b611ed38383611f4f565b5b949350505050565b600082511115611eef5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f239190612853565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600082511115611f625781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f969190612853565b60405180910390fd5b6000611fb2611fad84612ae8565b612ac3565b905082815260208101848484011115611fce57611fcd612c90565b5b611fd9848285612bdf565b509392505050565b600081359050611ff08161306a565b92915050565b60008151905061200581613081565b92915050565b60008151905061201a81613098565b92915050565b60008083601f84011261203657612035612c86565b5b8235905067ffffffffffffffff81111561205357612052612c81565b5b60208301915083600182028301111561206f5761206e612c8b565b5b9250929050565b600082601f83011261208b5761208a612c86565b5b813561209b848260208601611f9f565b91505092915050565b6000813590506120b3816130af565b92915050565b6000815190506120c8816130af565b92915050565b6000602082840312156120e4576120e3612c9a565b5b60006120f284828501611fe1565b91505092915050565b60008060008060006080868803121561211757612116612c9a565b5b600061212588828901611fe1565b955050602061213688828901611fe1565b9450506040612147888289016120a4565b935050606086013567ffffffffffffffff81111561216857612167612c95565b5b61217488828901612020565b92509250509295509295909350565b60008060006040848603121561219c5761219b612c9a565b5b60006121aa86828701611fe1565b935050602084013567ffffffffffffffff8111156121cb576121ca612c95565b5b6121d786828701612020565b92509250509250925092565b600080604083850312156121fa576121f9612c9a565b5b600061220885828601611fe1565b925050602083013567ffffffffffffffff81111561222957612228612c95565b5b61223585828601612076565b9150509250929050565b60008060006060848603121561225857612257612c9a565b5b600061226686828701611fe1565b9350506020612277868287016120a4565b925050604061228886828701611fe1565b9150509250925092565b6000806000806000608086880312156122ae576122ad612c9a565b5b60006122bc88828901611fe1565b95505060206122cd888289016120a4565b94505060406122de88828901611fe1565b935050606086013567ffffffffffffffff8111156122ff576122fe612c95565b5b61230b88828901612020565b92509250509295509295909350565b6000602082840312156123305761232f612c9a565b5b600061233e84828501611ff6565b91505092915050565b60006020828403121561235d5761235c612c9a565b5b600061236b8482850161200b565b91505092915050565b60006020828403121561238a57612389612c9a565b5b6000612398848285016120b9565b91505092915050565b6123aa81612b5c565b82525050565b6123b981612b7a565b82525050565b60006123cb8385612b2f565b93506123d8838584612bdf565b6123e183612c9f565b840190509392505050565b60006123f88385612b40565b9350612405838584612bdf565b82840190509392505050565b600061241c82612b19565b6124268185612b2f565b9350612436818560208601612bee565b61243f81612c9f565b840191505092915050565b600061245582612b19565b61245f8185612b40565b935061246f818560208601612bee565b80840191505092915050565b61248481612bbb565b82525050565b61249381612bcd565b82525050565b60006124a482612b24565b6124ae8185612b4b565b93506124be818560208601612bee565b6124c781612c9f565b840191505092915050565b60006124df602683612b4b565b91506124ea82612cb0565b604082019050919050565b6000612502602c83612b4b565b915061250d82612cff565b604082019050919050565b6000612525602c83612b4b565b915061253082612d4e565b604082019050919050565b6000612548602683612b4b565b915061255382612d9d565b604082019050919050565b600061256b603883612b4b565b915061257682612dec565b604082019050919050565b600061258e602983612b4b565b915061259982612e3b565b604082019050919050565b60006125b1602e83612b4b565b91506125bc82612e8a565b604082019050919050565b60006125d4602e83612b4b565b91506125df82612ed9565b604082019050919050565b60006125f7602d83612b4b565b915061260282612f28565b604082019050919050565b600061261a602083612b4b565b915061262582612f77565b602082019050919050565b600061263d600083612b2f565b915061264882612fa0565b600082019050919050565b6000612660600083612b40565b915061266b82612fa0565b600082019050919050565b6000612683601d83612b4b565b915061268e82612fa3565b602082019050919050565b60006126a6602b83612b4b565b91506126b182612fcc565b604082019050919050565b60006126c9602a83612b4b565b91506126d48261301b565b604082019050919050565b6126e881612ba4565b82525050565b60006126fb8284866123ec565b91508190509392505050565b6000612713828461244a565b915081905092915050565b600061272982612653565b9150819050919050565b600060208201905061274860008301846123a1565b92915050565b600060608201905061276360008301866123a1565b61277060208301856123a1565b61277d60408301846126df565b949350505050565b600060408201905061279a60008301856123a1565b6127a7602083018461247b565b9392505050565b60006040820190506127c360008301856123a1565b6127d060208301846126df565b9392505050565b60006020820190506127ec60008301846123b0565b92915050565b6000602082019050818103600083015261280d8184866123bf565b90509392505050565b600060208201905081810360008301526128308184612411565b905092915050565b600060208201905061284d600083018461248a565b92915050565b6000602082019050818103600083015261286d8184612499565b905092915050565b6000602082019050818103600083015261288e816124d2565b9050919050565b600060208201905081810360008301526128ae816124f5565b9050919050565b600060208201905081810360008301526128ce81612518565b9050919050565b600060208201905081810360008301526128ee8161253b565b9050919050565b6000602082019050818103600083015261290e8161255e565b9050919050565b6000602082019050818103600083015261292e81612581565b9050919050565b6000602082019050818103600083015261294e816125a4565b9050919050565b6000602082019050818103600083015261296e816125c7565b9050919050565b6000602082019050818103600083015261298e816125ea565b9050919050565b600060208201905081810360008301526129ae8161260d565b9050919050565b600060208201905081810360008301526129ce81612676565b9050919050565b600060208201905081810360008301526129ee81612699565b9050919050565b60006020820190508181036000830152612a0e816126bc565b9050919050565b6000606082019050612a2a60008301876126df565b612a3760208301866123a1565b8181036040830152612a4a8184866123bf565b905095945050505050565b6000606082019050612a6a60008301856126df565b612a7760208301846123a1565b8181036040830152612a8881612630565b90509392505050565b6000604082019050612aa660008301866126df565b8181036020830152612ab98184866123bf565b9050949350505050565b6000612acd612ade565b9050612ad98282612c21565b919050565b6000604051905090565b600067ffffffffffffffff821115612b0357612b02612c52565b5b612b0c82612c9f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612b6782612b84565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612bc682612ba4565b9050919050565b6000612bd882612bae565b9050919050565b82818337600083830152505050565b60005b83811015612c0c578082015181840152602081019050612bf1565b83811115612c1b576000848401525b50505050565b612c2a82612c9f565b810181811067ffffffffffffffff82111715612c4957612c48612c52565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61307381612b5c565b811461307e57600080fd5b50565b61308a81612b6e565b811461309557600080fd5b50565b6130a181612b7a565b81146130ac57600080fd5b50565b6130b881612ba4565b81146130c357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220154452ab17b7ec6558ae20cf0777deee4780b8e192489db9d10e2ac9e3d689a364736f6c6343000807003360806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea2646970667358221220c6f7c0f9935341aaaabcabf7504d01bbd38a0606132004742a97e6a200eb432564736f6c63430008070033a26469706673582212204918281ee3ff3c5665f56240e45c04fb90a737c9f0a7458612a8f8edd1468f7864736f6c63430008070033", + Bin: "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", } // GatewayEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go similarity index 73% rename from pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go rename to pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 5b272e90..7a9f8ef9 100644 --- a/pkg/contracts/prototypes/test/gatewayintegration.t.sol/gatewayintegrationtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package gatewayintegration +package gatewayevmzevm import ( "errors" @@ -47,23 +47,23 @@ type StdInvariantFuzzSelector struct { Selectors [][4]byte } -// GatewayIntegrationTestMetaData contains all meta data concerning the GatewayIntegrationTest contract. -var GatewayIntegrationTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x60806040526001600c60006101000a81548160ff0219169083151502179055506001601f60006101000a81548160ff02191690831515021790555034801561004657600080fd5b506201142f80620000586000396000f3fe60806040523480156200001157600080fd5b5060043610620001005760003560e01c8063916a17c61162000099578063b5508aa9116200006f578063b5508aa9146200022d578063ba414fa6146200024f578063e20c9f711462000271578063fa7626d414620002935762000100565b8063916a17c614620001dd5780639683c69514620001ff578063b0464fdc146200020b5762000100565b80633e5e3c2311620000db5780633e5e3c2314620001555780633f7286f4146200017757806366d9a9a0146200019957806385226c8114620001bb5762000100565b80630a9254e414620001055780631ed7831c14620001115780632ade38801462000133575b600080fd5b6200010f620002b5565b005b6200011b620010b4565b6040516200012a919062002c9b565b60405180910390f35b6200013d62001144565b6040516200014c919062002d07565b60405180910390f35b6200015f620012de565b6040516200016e919062002c9b565b60405180910390f35b620001816200136e565b60405162000190919062002c9b565b60405180910390f35b620001a3620013fe565b604051620001b2919062002ce3565b60405180910390f35b620001c562001595565b604051620001d4919062002cbf565b60405180910390f35b620001e762001678565b604051620001f6919062002d2b565b60405180910390f35b62000209620017cb565b005b6200021562001e6a565b60405162000224919062002d2b565b60405180910390f35b6200023762001fbd565b60405162000246919062002cbf565b60405180910390f35b62000259620020a0565b60405162000268919062002d4f565b60405180910390f35b6200027b620021d3565b6040516200028a919062002c9b565b60405180910390f35b6200029d62002263565b604051620002ac919062002d4f565b60405180910390f35b30602360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550611234602460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550615678602560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550614321602a60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620003cd9062002276565b620003d89062002f3a565b604051809103906000f080158015620003f5573d6000803e3d6000fd5b50602160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620004449062002284565b604051809103906000f08015801562000461573d6000803e3d6000fd5b50601f60016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16604051620004d39062002292565b620004df919062002b59565b604051809103906000f080158015620004fc573d6000803e3d6000fd5b50602060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c4d66de8602560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401620005bc919062002b59565b600060405180830381600087803b158015620005d757600080fd5b505af1158015620005ec573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ae7a3a6f602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200066f919062002b59565b600060405180830381600087803b1580156200068a57600080fd5b505af11580156200069f573d6000803e3d6000fd5b50505050602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b81526004016200072792919062002c14565b600060405180830381600087803b1580156200074257600080fd5b505af115801562000757573d6000803e3d6000fd5b50505050602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166207a1206040518363ffffffff1660e01b8152600401620007df92919062002c41565b602060405180830381600087803b158015620007fa57600080fd5b505af11580156200080f573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000835919062002392565b506040516200084490620022a0565b604051809103906000f08015801562000861573d6000803e3d6000fd5b50602260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550604051620008b090620022ae565b604051809103906000f080158015620008cd573d6000803e3d6000fd5b50602660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516200093f90620022bc565b6200094b919062002b59565b604051809103906000f08015801562000968573d6000803e3d6000fd5b50602760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600073735b14bb79463307aacbed86daf3322b1e6226ab90507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166306447d56826040518263ffffffff1660e01b815260040162000a20919062002b59565b600060405180830381600087803b15801562000a3b57600080fd5b505af115801562000a50573d6000803e3d6000fd5b50505050600080600060405162000a6790620022ca565b62000a759392919062002b76565b604051809103906000f08015801562000a92573d6000803e3d6000fd5b50602860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060126001600080602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405162000b2e90620022d8565b62000b3f9695949392919062002ea2565b604051809103906000f08015801562000b5c573d6000803e3d6000fd5b50602960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ee2815ba6001602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518363ffffffff1660e01b815260040162000c1f92919062002e04565b600060405180830381600087803b15801562000c3a57600080fd5b505af115801562000c4f573d6000803e3d6000fd5b50505050602860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a7cb05076001806040518363ffffffff1660e01b815260040162000cb392919062002e31565b600060405180830381600087803b15801562000cce57600080fd5b505af115801562000ce3573d6000803e3d6000fd5b50505050602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166347e7ef24602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b815260040162000d6b92919062002c14565b602060405180830381600087803b15801562000d8657600080fd5b505af115801562000d9b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000dc1919062002392565b50602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166347e7ef24602760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b815260040162000e4692919062002c14565b602060405180830381600087803b15801562000e6157600080fd5b505af115801562000e76573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019062000e9c919062002392565b507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166390c5013b6040518163ffffffff1660e01b8152600401600060405180830381600087803b15801562000f0957600080fd5b505af115801562000f1e573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663ca669fa7602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b815260040162000fa2919062002b59565b600060405180830381600087803b15801562000fbd57600080fd5b505af115801562000fd2573d6000803e3d6000fd5b50505050602960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663095ea7b3602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b81526004016200105a92919062002c14565b602060405180830381600087803b1580156200107557600080fd5b505af11580156200108a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620010b0919062002392565b5050565b606060168054806020026020016040519081016040528092919081815260200182805480156200113a57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620010ef575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020016000905b82821015620012d557838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020016000905b82821015620012bd578382906000526020600020018054620012299062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620012579062003340565b8015620012a85780601f106200127c57610100808354040283529160200191620012a8565b820191906000526020600020905b8154815290600101906020018083116200128a57829003601f168201915b50505050508152602001906001019062001207565b50505050815250508152602001906001019062001168565b50505050905090565b606060188054806020026020016040519081016040528092919081815260200182805480156200136457602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162001319575b5050505050905090565b60606017805480602002602001604051908101604052809291908181526020018280548015620013f457602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620013a9575b5050505050905090565b6060601b805480602002602001604051908101604052809291908181526020016000905b828210156200158c5783829060005260206000209060020201604051806040016040529081600082018054620014589062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620014869062003340565b8015620014d75780601f10620014ab57610100808354040283529160200191620014d7565b820191906000526020600020905b815481529060010190602001808311620014b957829003601f168201915b50505050508152602001600182018054806020026020016040519081016040528092919081815260200182805480156200157357602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916815260200190600401906020826003010492830192600103820291508084116200151f5790505b5050505050815250508152602001906001019062001422565b50505050905090565b6060601a805480602002602001604051908101604052809291908181526020016000905b828210156200166f578382906000526020600020018054620015db9062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620016099062003340565b80156200165a5780601f106200162e576101008083540402835291602001916200165a565b820191906000526020600020905b8154815290600101906020018083116200163c57829003601f168201915b505050505081526020019060010190620015b9565b50505050905090565b6060601d805480602002602001604051908101604052809291908181526020016000905b82821015620017c257838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020018280548015620017a957602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411620017555790505b505050505081525050815260200190600101906200169c565b50505050905090565b60006040518060400160405280600f81526020017f48656c6c6f2c204861726468617421000000000000000000000000000000000081525090506000602a90506000600190506000670de0b6b3a76400009050600063e04d4f9760e01b8585856040516024016200183f9392919062002e5e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663ca669fa7602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200191e919062002b59565b600060405180830381600087803b1580156200193957600080fd5b505af11580156200194e573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b8152600401620019dc95949392919062002d6c565b600060405180830381600087803b158015620019f757600080fd5b505af115801562001a0c573d6000803e3d6000fd5b50505050602a60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405160200162001a9f919062002b3c565b6040516020818303038152906040528360405162001abf92919062002dc9565b60405180910390a2602660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405160200162001b3a919062002b3c565b604051602081830303815290604052836040518363ffffffff1660e01b815260040162001b6992919062002dc9565b600060405180830381600087803b15801562001b8457600080fd5b505af115801562001b99573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663c88a5e6d601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518363ffffffff1660e01b815260040162001c1f92919062002c6e565b600060405180830381600087803b15801562001c3a57600080fd5b505af115801562001c4f573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b815260040162001cdd95949392919062002d6c565b600060405180830381600087803b15801562001cf857600080fd5b505af115801562001d0d573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f838360405162001d7d92919062002f71565b60405180910390a2601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16631cff79cd83602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b815260040162001e0792919062002be0565b6000604051808303818588803b15801562001e2157600080fd5b505af115801562001e36573d6000803e3d6000fd5b50505050506040513d6000823e3d601f19601f8201168201806040525081019062001e629190620023f6565b505050505050565b6060601c805480602002602001604051908101604052809291908181526020016000905b8282101562001fb457838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020016001820180548060200260200160405190810160405280929190818152602001828054801562001f9b57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162001f475790505b5050505050815250508152602001906001019062001e8e565b50505050905090565b60606019805480602002602001604051908101604052809291908181526020016000905b8282101562002097578382906000526020600020018054620020039062003340565b80601f0160208091040260200160405190810160405280929190818152602001828054620020319062003340565b8015620020825780601f10620020565761010080835404028352916020019162002082565b820191906000526020600020905b8154815290600101906020018083116200206457829003601f168201915b50505050508152602001906001019062001fe1565b50505050905090565b6000600860009054906101000a900460ff1615620020d057600860009054906101000a900460ff169050620021d0565b6000801b7f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663667f9d707f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c7f6661696c656400000000000000000000000000000000000000000000000000006040518363ffffffff1660e01b81526004016200217792919062002bb3565b60206040518083038186803b1580156200219057600080fd5b505afa158015620021a5573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620021cb9190620023c4565b141590505b90565b606060158054806020026020016040519081016040528092919081815260200182805480156200225957602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190600101908083116200220e575b5050505050905090565b601f60009054906101000a900460ff1681565b611813806200358383390190565b6131a48062004d9683390190565b6110908062007f3a83390190565b6110aa8062008fca83390190565b612eb5806200a07483390190565b610bcd806200cf2983390190565b6110d7806200daf683390190565b61282d806200ebcd83390190565b6000620022fd620022f78462002fce565b62002fa5565b9050828152602081018484840111156200231c576200231b62003466565b5b620023298482856200330a565b509392505050565b60008151905062002342816200354e565b92915050565b600081519050620023598162003568565b92915050565b600082601f83011262002377576200237662003461565b5b815162002389848260208601620022e6565b91505092915050565b600060208284031215620023ab57620023aa62003470565b5b6000620023bb8482850162002331565b91505092915050565b600060208284031215620023dd57620023dc62003470565b5b6000620023ed8482850162002348565b91505092915050565b6000602082840312156200240f576200240e62003470565b5b600082015167ffffffffffffffff81111562002430576200242f6200346b565b5b6200243e848285016200235f565b91505092915050565b6000620024558383620024d3565b60208301905092915050565b60006200246f838362002870565b60208301905092915050565b600062002489838362002943565b905092915050565b60006200249f838362002a61565b905092915050565b6000620024b5838362002aa9565b905092915050565b6000620024cb838362002aea565b905092915050565b620024de81620031b4565b82525050565b620024ef81620031b4565b82525050565b6000620025028262003064565b6200250e81856200310a565b93506200251b8362003004565b8060005b838110156200255257815162002536888262002447565b97506200254383620030bc565b9250506001810190506200251f565b5085935050505092915050565b60006200256c826200306f565b6200257881856200311b565b9350620025858362003014565b8060005b83811015620025bc578151620025a0888262002461565b9750620025ad83620030c9565b92505060018101905062002589565b5085935050505092915050565b6000620025d6826200307a565b620025e281856200312c565b935083602082028501620025f68562003024565b8060005b858110156200263857848403895281516200261685826200247b565b94506200262383620030d6565b925060208a01995050600181019050620025fa565b50829750879550505050505092915050565b600062002657826200307a565b6200266381856200313d565b935083602082028501620026778562003024565b8060005b85811015620026b957848403895281516200269785826200247b565b9450620026a483620030d6565b925060208a019950506001810190506200267b565b50829750879550505050505092915050565b6000620026d88262003085565b620026e481856200314e565b935083602082028501620026f88562003034565b8060005b858110156200273a578484038952815162002718858262002491565b94506200272583620030e3565b925060208a01995050600181019050620026fc565b50829750879550505050505092915050565b6000620027598262003090565b6200276581856200315f565b935083602082028501620027798562003044565b8060005b85811015620027bb5784840389528151620027998582620024a7565b9450620027a683620030f0565b925060208a019950506001810190506200277d565b50829750879550505050505092915050565b6000620027da826200309b565b620027e6818562003170565b935083602082028501620027fa8562003054565b8060005b858110156200283c57848403895281516200281a8582620024bd565b94506200282783620030fd565b925060208a01995050600181019050620027fe565b50829750879550505050505092915050565b6200285981620031c8565b82525050565b6200286a81620031d4565b82525050565b6200287b81620031de565b82525050565b60006200288e82620030a6565b6200289a818562003181565b9350620028ac8185602086016200330a565b620028b78162003475565b840191505092915050565b620028d7620028d18262003256565b620033ac565b82525050565b620028e8816200326a565b82525050565b620028f9816200327e565b82525050565b6200290a8162003292565b82525050565b6200291b81620032a6565b82525050565b6200292c81620032ba565b82525050565b6200293d81620032ce565b82525050565b60006200295082620030b1565b6200295c818562003192565b93506200296e8185602086016200330a565b620029798162003475565b840191505092915050565b60006200299182620030b1565b6200299d8185620031a3565b9350620029af8185602086016200330a565b620029ba8162003475565b840191505092915050565b6000620029d4600383620031a3565b9150620029e18262003493565b602082019050919050565b6000620029fb600583620031a3565b915062002a0882620034bc565b602082019050919050565b600062002a22600483620031a3565b915062002a2f82620034e5565b602082019050919050565b600062002a49600383620031a3565b915062002a56826200350e565b602082019050919050565b6000604083016000830151848203600086015262002a80828262002943565b9150506020830151848203602086015262002a9c82826200255f565b9150508091505092915050565b600060408301600083015162002ac36000860182620024d3565b506020830151848203602086015262002add8282620025c9565b9150508091505092915050565b600060408301600083015162002b046000860182620024d3565b506020830151848203602086015262002b1e82826200255f565b9150508091505092915050565b62002b36816200323f565b82525050565b600062002b4a8284620028c2565b60148201915081905092915050565b600060208201905062002b706000830184620024e4565b92915050565b600060608201905062002b8d6000830186620024e4565b62002b9c6020830185620024e4565b62002bab6040830184620024e4565b949350505050565b600060408201905062002bca6000830185620024e4565b62002bd960208301846200285f565b9392505050565b600060408201905062002bf76000830185620024e4565b818103602083015262002c0b818462002881565b90509392505050565b600060408201905062002c2b6000830185620024e4565b62002c3a6020830184620028ff565b9392505050565b600060408201905062002c586000830185620024e4565b62002c67602083018462002932565b9392505050565b600060408201905062002c856000830185620024e4565b62002c94602083018462002b2b565b9392505050565b6000602082019050818103600083015262002cb78184620024f5565b905092915050565b6000602082019050818103600083015262002cdb81846200264a565b905092915050565b6000602082019050818103600083015262002cff8184620026cb565b905092915050565b6000602082019050818103600083015262002d2381846200274c565b905092915050565b6000602082019050818103600083015262002d478184620027cd565b905092915050565b600060208201905062002d6660008301846200284e565b92915050565b600060a08201905062002d8360008301886200284e565b62002d9260208301876200284e565b62002da160408301866200284e565b62002db060608301856200284e565b62002dbf6080830184620024e4565b9695505050505050565b6000604082019050818103600083015262002de5818562002881565b9050818103602083015262002dfb818462002881565b90509392505050565b600060408201905062002e1b600083018562002921565b62002e2a6020830184620024e4565b9392505050565b600060408201905062002e48600083018562002921565b62002e57602083018462002921565b9392505050565b6000606082019050818103600083015262002e7a818662002984565b905062002e8b602083018562002b2b565b62002e9a60408301846200284e565b949350505050565b600061010082019050818103600083015262002ebe81620029ec565b9050818103602083015262002ed38162002a3a565b905062002ee4604083018962002910565b62002ef3606083018862002921565b62002f026080830187620028dd565b62002f1160a0830186620028ee565b62002f2060c0830185620024e4565b62002f2f60e0830184620024e4565b979650505050505050565b6000604082019050818103600083015262002f558162002a13565b9050818103602083015262002f6a81620029c5565b9050919050565b600060408201905062002f88600083018562002b2b565b818103602083015262002f9c818462002881565b90509392505050565b600062002fb162002fc4565b905062002fbf828262003376565b919050565b6000604051905090565b600067ffffffffffffffff82111562002fec5762002feb62003432565b5b62002ff78262003475565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000620031c1826200321f565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b60008190506200321a8262003537565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006200326382620032e2565b9050919050565b600062003277826200320a565b9050919050565b60006200328b826200323f565b9050919050565b60006200329f826200323f565b9050919050565b6000620032b38262003249565b9050919050565b6000620032c7826200323f565b9050919050565b6000620032db826200323f565b9050919050565b6000620032ef82620032f6565b9050919050565b600062003303826200321f565b9050919050565b60005b838110156200332a5780820151818401526020810190506200330d565b838111156200333a576000848401525b50505050565b600060028204905060018216806200335957607f821691505b6020821081141562003370576200336f62003403565b5b50919050565b620033818262003475565b810181811067ffffffffffffffff82111715620033a357620033a262003432565b5b80604052505050565b6000620033b982620033c0565b9050919050565b6000620033cd8262003486565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f54544b0000000000000000000000000000000000000000000000000000000000600082015250565b7f544f4b454e000000000000000000000000000000000000000000000000000000600082015250565b7f7465737400000000000000000000000000000000000000000000000000000000600082015250565b7f544b4e0000000000000000000000000000000000000000000000000000000000600082015250565b600381106200354b576200354a620033d4565b5b50565b6200355981620031c8565b81146200356557600080fd5b50565b6200357381620031d4565b81146200357f57600080fd5b5056fe60806040523480156200001157600080fd5b5060405162001813380380620018138339818101604052810190620000379190620001a3565b818181600390805190602001906200005192919062000075565b5080600490805190602001906200006a92919062000075565b5050505050620003ac565b8280546200008390620002bd565b90600052602060002090601f016020900481019282620000a75760008555620000f3565b82601f10620000c257805160ff1916838001178555620000f3565b82800160010185558215620000f3579182015b82811115620000f2578251825591602001919060010190620000d5565b5b50905062000102919062000106565b5090565b5b808211156200012157600081600090555060010162000107565b5090565b60006200013c620001368462000251565b62000228565b9050828152602081018484840111156200015b576200015a6200038c565b5b6200016884828562000287565b509392505050565b600082601f83011262000188576200018762000387565b5b81516200019a84826020860162000125565b91505092915050565b60008060408385031215620001bd57620001bc62000396565b5b600083015167ffffffffffffffff811115620001de57620001dd62000391565b5b620001ec8582860162000170565b925050602083015167ffffffffffffffff81111562000210576200020f62000391565b5b6200021e8582860162000170565b9150509250929050565b60006200023462000247565b9050620002428282620002f3565b919050565b6000604051905090565b600067ffffffffffffffff8211156200026f576200026e62000358565b5b6200027a826200039b565b9050602081019050919050565b60005b83811015620002a75780820151818401526020810190506200028a565b83811115620002b7576000848401525b50505050565b60006002820490506001821680620002d657607f821691505b60208210811415620002ed57620002ec62000329565b5b50919050565b620002fe826200039b565b810181811067ffffffffffffffff8211171562000320576200031f62000358565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b61145780620003bc6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c806340c10f191161007157806340c10f19146101a357806370a08231146101bf57806395d89b41146101ef578063a457c2d71461020d578063a9059cbb1461023d578063dd62ed3e1461026d576100b4565b806306fdde03146100b9578063095ea7b3146100d757806318160ddd1461010757806323b872dd14610125578063313ce567146101555780633950935114610173575b600080fd5b6100c161029d565b6040516100ce9190610ecf565b60405180910390f35b6100f160048036038101906100ec9190610cf6565b61032f565b6040516100fe9190610eb4565b60405180910390f35b61010f610352565b60405161011c9190610ff1565b60405180910390f35b61013f600480360381019061013a9190610ca3565b61035c565b60405161014c9190610eb4565b60405180910390f35b61015d61038b565b60405161016a919061100c565b60405180910390f35b61018d60048036038101906101889190610cf6565b610394565b60405161019a9190610eb4565b60405180910390f35b6101bd60048036038101906101b89190610cf6565b6103cb565b005b6101d960048036038101906101d49190610c36565b6103d9565b6040516101e69190610ff1565b60405180910390f35b6101f7610421565b6040516102049190610ecf565b60405180910390f35b61022760048036038101906102229190610cf6565b6104b3565b6040516102349190610eb4565b60405180910390f35b61025760048036038101906102529190610cf6565b61052a565b6040516102649190610eb4565b60405180910390f35b61028760048036038101906102829190610c63565b61054d565b6040516102949190610ff1565b60405180910390f35b6060600380546102ac90611121565b80601f01602080910402602001604051908101604052809291908181526020018280546102d890611121565b80156103255780601f106102fa57610100808354040283529160200191610325565b820191906000526020600020905b81548152906001019060200180831161030857829003601f168201915b5050505050905090565b60008061033a6105d4565b90506103478185856105dc565b600191505092915050565b6000600254905090565b6000806103676105d4565b90506103748582856107a7565b61037f858585610833565b60019150509392505050565b60006012905090565b60008061039f6105d4565b90506103c08185856103b1858961054d565b6103bb9190611043565b6105dc565b600191505092915050565b6103d58282610aab565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60606004805461043090611121565b80601f016020809104026020016040519081016040528092919081815260200182805461045c90611121565b80156104a95780601f1061047e576101008083540402835291602001916104a9565b820191906000526020600020905b81548152906001019060200180831161048c57829003601f168201915b5050505050905090565b6000806104be6105d4565b905060006104cc828661054d565b905083811015610511576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050890610fb1565b60405180910390fd5b61051e82868684036105dc565b60019250505092915050565b6000806105356105d4565b9050610542818585610833565b600191505092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610f91565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156106bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106b390610f11565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161079a9190610ff1565b60405180910390a3505050565b60006107b3848461054d565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461082d578181101561081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690610f31565b60405180910390fd5b61082c84848484036105dc565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156108a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089a90610f71565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610913576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090a90610ef1565b60405180910390fd5b61091e838383610c02565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156109a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099b90610f51565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a929190610ff1565b60405180910390a3610aa5848484610c07565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610b1b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1290610fd1565b60405180910390fd5b610b2760008383610c02565b8060026000828254610b399190611043565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051610bea9190610ff1565b60405180910390a3610bfe60008383610c07565b5050565b505050565b505050565b600081359050610c1b816113f3565b92915050565b600081359050610c308161140a565b92915050565b600060208284031215610c4c57610c4b6111b1565b5b6000610c5a84828501610c0c565b91505092915050565b60008060408385031215610c7a57610c796111b1565b5b6000610c8885828601610c0c565b9250506020610c9985828601610c0c565b9150509250929050565b600080600060608486031215610cbc57610cbb6111b1565b5b6000610cca86828701610c0c565b9350506020610cdb86828701610c0c565b9250506040610cec86828701610c21565b9150509250925092565b60008060408385031215610d0d57610d0c6111b1565b5b6000610d1b85828601610c0c565b9250506020610d2c85828601610c21565b9150509250929050565b610d3f816110ab565b82525050565b6000610d5082611027565b610d5a8185611032565b9350610d6a8185602086016110ee565b610d73816111b6565b840191505092915050565b6000610d8b602383611032565b9150610d96826111c7565b604082019050919050565b6000610dae602283611032565b9150610db982611216565b604082019050919050565b6000610dd1601d83611032565b9150610ddc82611265565b602082019050919050565b6000610df4602683611032565b9150610dff8261128e565b604082019050919050565b6000610e17602583611032565b9150610e22826112dd565b604082019050919050565b6000610e3a602483611032565b9150610e458261132c565b604082019050919050565b6000610e5d602583611032565b9150610e688261137b565b604082019050919050565b6000610e80601f83611032565b9150610e8b826113ca565b602082019050919050565b610e9f816110d7565b82525050565b610eae816110e1565b82525050565b6000602082019050610ec96000830184610d36565b92915050565b60006020820190508181036000830152610ee98184610d45565b905092915050565b60006020820190508181036000830152610f0a81610d7e565b9050919050565b60006020820190508181036000830152610f2a81610da1565b9050919050565b60006020820190508181036000830152610f4a81610dc4565b9050919050565b60006020820190508181036000830152610f6a81610de7565b9050919050565b60006020820190508181036000830152610f8a81610e0a565b9050919050565b60006020820190508181036000830152610faa81610e2d565b9050919050565b60006020820190508181036000830152610fca81610e50565b9050919050565b60006020820190508181036000830152610fea81610e73565b9050919050565b60006020820190506110066000830184610e96565b92915050565b60006020820190506110216000830184610ea5565b92915050565b600081519050919050565b600082825260208201905092915050565b600061104e826110d7565b9150611059836110d7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561108e5761108d611153565b5b828201905092915050565b60006110a4826110b7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561110c5780820151818401526020810190506110f1565b8381111561111b576000848401525b50505050565b6000600282049050600182168061113957607f821691505b6020821081141561114d5761114c611182565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6113fc81611099565b811461140757600080fd5b50565b611413816110d7565b811461141e57600080fd5b5056fea2646970667358221220d4c96329400732e284f624232c8d7228fc90c00ee7b1a48a85080262107815d864736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c613123610081600039600081816105fc0152818161068b01528181610785015281816108140152610bae01526131236000f3fe6080604052600436106100fe5760003560e01c8063715018a611610095578063c4d66de811610064578063c4d66de8146102e4578063dda79b751461030d578063f2fde38b14610338578063f340fa0114610361578063f45346dc1461037d576100fe565b8063715018a6146102505780638c6f037f146102675780638da5cb5b14610290578063ae7a3a6f146102bb576100fe565b80634f1ef286116100d15780634f1ef286146101a15780635131ab59146101bd57806352d1902d146101fa5780635b11259114610225576100fe565b80631b8b921d146101035780631cff79cd1461012c57806329c59b5d1461015c5780633659cfe614610178575b600080fd5b34801561010f57600080fd5b5061012a60048036038101906101259190612183565b6103a6565b005b61014660048036038101906101419190612183565b610412565b6040516101539190612816565b60405180910390f35b61017660048036038101906101719190612183565b610480565b005b34801561018457600080fd5b5061019f600480360381019061019a91906120ce565b6105fa565b005b6101bb60048036038101906101b691906121e3565b610783565b005b3480156101c957600080fd5b506101e460048036038101906101df91906120fb565b6108c0565b6040516101f19190612816565b60405180910390f35b34801561020657600080fd5b5061020f610baa565b60405161021c91906127d7565b60405180910390f35b34801561023157600080fd5b5061023a610c63565b6040516102479190612733565b60405180910390f35b34801561025c57600080fd5b50610265610c89565b005b34801561027357600080fd5b5061028e60048036038101906102899190612292565b610c9d565b005b34801561029c57600080fd5b506102a5610d99565b6040516102b29190612733565b60405180910390f35b3480156102c757600080fd5b506102e260048036038101906102dd91906120ce565b610dc3565b005b3480156102f057600080fd5b5061030b600480360381019061030691906120ce565b610e8f565b005b34801561031957600080fd5b5061032261107e565b60405161032f9190612733565b60405180910390f35b34801561034457600080fd5b5061035f600480360381019061035a91906120ce565b6110a4565b005b61037b600480360381019061037691906120ce565b611128565b005b34801561038957600080fd5b506103a4600480360381019061039f919061223f565b61129c565b005b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde384846040516104059291906127f2565b60405180910390a3505050565b60606000610421858585611392565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f34868660405161046d93929190612a91565b60405180910390a2809150509392505050565b60003414156104bb576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516105039061271e565b60006040518083038185875af1925050503d8060008114610540576040519150601f19603f3d011682016040523d82523d6000602084013e610545565b606091505b50509050600015158115151415610588576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516105ec9493929190612a15565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610689576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068090612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106c8611449565b73ffffffffffffffffffffffffffffffffffffffff161461071e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610715906128b5565b60405180910390fd5b610727816114a0565b61078081600067ffffffffffffffff81111561074657610745612c52565b5b6040519080825280601f01601f1916602001820160405280156107785781602001600182028036833780820191505090505b5060006114ab565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610812576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161080990612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610851611449565b73ffffffffffffffffffffffffffffffffffffffff16146108a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089e906128b5565b60405180910390fd5b6108b0826114a0565b6108bc828260016114ab565b5050565b606060008414156108fd576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6109078686611628565b61093d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016109789291906127ae565b602060405180830381600087803b15801561099257600080fd5b505af11580156109a6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109ca919061231a565b610a00576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610a0d868585611392565b9050610a198787611628565b610a4f576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a8a9190612733565b60206040518083038186803b158015610aa257600080fd5b505afa158015610ab6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ada9190612374565b90506000811115610b3357610b3260c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16828a73ffffffffffffffffffffffffffffffffffffffff166116c09092919063ffffffff16565b5b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610b9493929190612a91565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610c3a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c31906128f5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610c91611746565b610c9b60006117c4565b565b6000841415610cd8576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610d273360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868673ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a486868686604051610d8a9493929190612a15565b60405180910390a35050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e4b576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610ec05750600160008054906101000a900460ff1660ff16105b80610eed5750610ecf30611913565b158015610eec5750600160008054906101000a900460ff1660ff16145b5b610f2c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f2390612935565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610f69576001600060016101000a81548160ff0219169083151502179055505b610f71611936565b610f7961198f565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610fe0576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550801561107a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860016040516110719190612838565b60405180910390a15b5050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110ac611746565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561111c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111390612875565b60405180910390fd5b611125816117c4565b50565b6000341415611163576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516111ab9061271e565b60006040518083038185875af1925050503d80600081146111e8576040519150601f19603f3d011682016040523d82523d6000602084013e6111ed565b606091505b50509050600015158115151415611230576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4346000604051611290929190612a55565b60405180910390a35050565b60008214156112d7576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113263360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848473ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48484604051611385929190612a55565b60405180910390a3505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff163486866040516113bf9291906126ee565b60006040518083038185875af1925050503d80600081146113fc576040519150601f19603f3d011682016040523d82523d6000602084013e611401565b606091505b50915091508161143d576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006114777f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6114a8611746565b50565b6114d77f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6119ea565b60000160009054906101000a900460ff16156114fb576114f6836119f4565b611623565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561154157600080fd5b505afa92505050801561157257506040513d601f19601f8201168201806040525081019061156f9190612347565b60015b6115b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115a890612955565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611616576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160d90612915565b60405180910390fd5b50611622838383611aad565b5b505050565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611666929190612785565b602060405180830381600087803b15801561168057600080fd5b505af1158015611694573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116b8919061231a565b905092915050565b6117418363a9059cbb60e01b84846040516024016116df9291906127ae565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b505050565b61174e611ba0565b73ffffffffffffffffffffffffffffffffffffffff1661176c610d99565b73ffffffffffffffffffffffffffffffffffffffff16146117c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117b990612995565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61190d846323b872dd60e01b8585856040516024016118ab9392919061274e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b50505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611985576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161197c906129d5565b60405180910390fd5b61198d611ba8565b565b600060019054906101000a900460ff166119de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119d5906129d5565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6119fd81611913565b611a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a3390612975565b60405180910390fd5b80611a697f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611ab683611c09565b600082511180611ac35750805b15611ad457611ad28383611c58565b505b505050565b6000611b3b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16611c859092919063ffffffff16565b9050600081511115611b9b5780806020019051810190611b5b919061231a565b611b9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b91906129f5565b60405180910390fd5b5b505050565b600033905090565b600060019054906101000a900460ff16611bf7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611bee906129d5565b60405180910390fd5b611c07611c02611ba0565b6117c4565b565b611c12816119f4565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611c7d83836040518060600160405280602781526020016130c760279139611c9d565b905092915050565b6060611c948484600085611d23565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1685604051611cc79190612707565b600060405180830381855af49150503d8060008114611d02576040519150601f19603f3d011682016040523d82523d6000602084013e611d07565b606091505b5091509150611d1886838387611df0565b925050509392505050565b606082471015611d68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d5f906128d5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611d919190612707565b60006040518083038185875af1925050503d8060008114611dce576040519150601f19603f3d011682016040523d82523d6000602084013e611dd3565b606091505b5091509150611de487838387611e66565b92505050949350505050565b60608315611e5357600083511415611e4b57611e0b85611913565b611e4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e41906129b5565b60405180910390fd5b5b829050611e5e565b611e5d8383611edc565b5b949350505050565b60608315611ec957600083511415611ec157611e8185611f2c565b611ec0576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611eb7906129b5565b60405180910390fd5b5b829050611ed4565b611ed38383611f4f565b5b949350505050565b600082511115611eef5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f239190612853565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600082511115611f625781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f969190612853565b60405180910390fd5b6000611fb2611fad84612ae8565b612ac3565b905082815260208101848484011115611fce57611fcd612c90565b5b611fd9848285612bdf565b509392505050565b600081359050611ff08161306a565b92915050565b60008151905061200581613081565b92915050565b60008151905061201a81613098565b92915050565b60008083601f84011261203657612035612c86565b5b8235905067ffffffffffffffff81111561205357612052612c81565b5b60208301915083600182028301111561206f5761206e612c8b565b5b9250929050565b600082601f83011261208b5761208a612c86565b5b813561209b848260208601611f9f565b91505092915050565b6000813590506120b3816130af565b92915050565b6000815190506120c8816130af565b92915050565b6000602082840312156120e4576120e3612c9a565b5b60006120f284828501611fe1565b91505092915050565b60008060008060006080868803121561211757612116612c9a565b5b600061212588828901611fe1565b955050602061213688828901611fe1565b9450506040612147888289016120a4565b935050606086013567ffffffffffffffff81111561216857612167612c95565b5b61217488828901612020565b92509250509295509295909350565b60008060006040848603121561219c5761219b612c9a565b5b60006121aa86828701611fe1565b935050602084013567ffffffffffffffff8111156121cb576121ca612c95565b5b6121d786828701612020565b92509250509250925092565b600080604083850312156121fa576121f9612c9a565b5b600061220885828601611fe1565b925050602083013567ffffffffffffffff81111561222957612228612c95565b5b61223585828601612076565b9150509250929050565b60008060006060848603121561225857612257612c9a565b5b600061226686828701611fe1565b9350506020612277868287016120a4565b925050604061228886828701611fe1565b9150509250925092565b6000806000806000608086880312156122ae576122ad612c9a565b5b60006122bc88828901611fe1565b95505060206122cd888289016120a4565b94505060406122de88828901611fe1565b935050606086013567ffffffffffffffff8111156122ff576122fe612c95565b5b61230b88828901612020565b92509250509295509295909350565b6000602082840312156123305761232f612c9a565b5b600061233e84828501611ff6565b91505092915050565b60006020828403121561235d5761235c612c9a565b5b600061236b8482850161200b565b91505092915050565b60006020828403121561238a57612389612c9a565b5b6000612398848285016120b9565b91505092915050565b6123aa81612b5c565b82525050565b6123b981612b7a565b82525050565b60006123cb8385612b2f565b93506123d8838584612bdf565b6123e183612c9f565b840190509392505050565b60006123f88385612b40565b9350612405838584612bdf565b82840190509392505050565b600061241c82612b19565b6124268185612b2f565b9350612436818560208601612bee565b61243f81612c9f565b840191505092915050565b600061245582612b19565b61245f8185612b40565b935061246f818560208601612bee565b80840191505092915050565b61248481612bbb565b82525050565b61249381612bcd565b82525050565b60006124a482612b24565b6124ae8185612b4b565b93506124be818560208601612bee565b6124c781612c9f565b840191505092915050565b60006124df602683612b4b565b91506124ea82612cb0565b604082019050919050565b6000612502602c83612b4b565b915061250d82612cff565b604082019050919050565b6000612525602c83612b4b565b915061253082612d4e565b604082019050919050565b6000612548602683612b4b565b915061255382612d9d565b604082019050919050565b600061256b603883612b4b565b915061257682612dec565b604082019050919050565b600061258e602983612b4b565b915061259982612e3b565b604082019050919050565b60006125b1602e83612b4b565b91506125bc82612e8a565b604082019050919050565b60006125d4602e83612b4b565b91506125df82612ed9565b604082019050919050565b60006125f7602d83612b4b565b915061260282612f28565b604082019050919050565b600061261a602083612b4b565b915061262582612f77565b602082019050919050565b600061263d600083612b2f565b915061264882612fa0565b600082019050919050565b6000612660600083612b40565b915061266b82612fa0565b600082019050919050565b6000612683601d83612b4b565b915061268e82612fa3565b602082019050919050565b60006126a6602b83612b4b565b91506126b182612fcc565b604082019050919050565b60006126c9602a83612b4b565b91506126d48261301b565b604082019050919050565b6126e881612ba4565b82525050565b60006126fb8284866123ec565b91508190509392505050565b6000612713828461244a565b915081905092915050565b600061272982612653565b9150819050919050565b600060208201905061274860008301846123a1565b92915050565b600060608201905061276360008301866123a1565b61277060208301856123a1565b61277d60408301846126df565b949350505050565b600060408201905061279a60008301856123a1565b6127a7602083018461247b565b9392505050565b60006040820190506127c360008301856123a1565b6127d060208301846126df565b9392505050565b60006020820190506127ec60008301846123b0565b92915050565b6000602082019050818103600083015261280d8184866123bf565b90509392505050565b600060208201905081810360008301526128308184612411565b905092915050565b600060208201905061284d600083018461248a565b92915050565b6000602082019050818103600083015261286d8184612499565b905092915050565b6000602082019050818103600083015261288e816124d2565b9050919050565b600060208201905081810360008301526128ae816124f5565b9050919050565b600060208201905081810360008301526128ce81612518565b9050919050565b600060208201905081810360008301526128ee8161253b565b9050919050565b6000602082019050818103600083015261290e8161255e565b9050919050565b6000602082019050818103600083015261292e81612581565b9050919050565b6000602082019050818103600083015261294e816125a4565b9050919050565b6000602082019050818103600083015261296e816125c7565b9050919050565b6000602082019050818103600083015261298e816125ea565b9050919050565b600060208201905081810360008301526129ae8161260d565b9050919050565b600060208201905081810360008301526129ce81612676565b9050919050565b600060208201905081810360008301526129ee81612699565b9050919050565b60006020820190508181036000830152612a0e816126bc565b9050919050565b6000606082019050612a2a60008301876126df565b612a3760208301866123a1565b8181036040830152612a4a8184866123bf565b905095945050505050565b6000606082019050612a6a60008301856126df565b612a7760208301846123a1565b8181036040830152612a8881612630565b90509392505050565b6000604082019050612aa660008301866126df565b8181036020830152612ab98184866123bf565b9050949350505050565b6000612acd612ade565b9050612ad98282612c21565b919050565b6000604051905090565b600067ffffffffffffffff821115612b0357612b02612c52565b5b612b0c82612c9f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612b6782612b84565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612bc682612ba4565b9050919050565b6000612bd882612bae565b9050919050565b82818337600083830152505050565b60005b83811015612c0c578082015181840152602081019050612bf1565b83811115612c1b576000848401525b50505050565b612c2a82612c9f565b810181811067ffffffffffffffff82111715612c4957612c48612c52565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61307381612b5c565b811461307e57600080fd5b50565b61308a81612b6e565b811461309557600080fd5b50565b6130a181612b7a565b81146130ac57600080fd5b50565b6130b881612ba4565b81146130c357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220154452ab17b7ec6558ae20cf0777deee4780b8e192489db9d10e2ac9e3d689a364736f6c6343000807003360806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea2646970667358221220c6f7c0f9935341aaaabcabf7504d01bbd38a0606132004742a97e6a200eb432564736f6c63430008070033608060405234801561001057600080fd5b5061108a806100206000396000f3fe60806040526004361061003f5760003560e01c8063357fc5a2146100445780636ed701691461006d578063e04d4f9714610084578063f05b6abf146100a0575b600080fd5b34801561005057600080fd5b5061006b6004803603810190610066919061085a565b6100c9565b005b34801561007957600080fd5b50610082610138565b005b61009e600480360381019061009991906107eb565b610171565b005b3480156100ac57600080fd5b506100c760048036038101906100c29190610733565b6101b5565b005b6100f63382858573ffffffffffffffffffffffffffffffffffffffff166101f7909392919063ffffffff16565b7f2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af603384848460405161012b9493929190610bb0565b60405180910390a1505050565b7fbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0336040516101679190610b0b565b60405180910390a1565b7f1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa33348585856040516101a8959493929190610bf5565b60405180910390a1505050565b7f74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146338484846040516101ea9493929190610b5d565b60405180910390a1505050565b61027a846323b872dd60e01b85858560405160240161021893929190610b26565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610280565b50505050565b60006102e2826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166103479092919063ffffffff16565b9050600081511115610342578080602001905181019061030291906107be565b610341576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161033890610cb1565b60405180910390fd5b5b505050565b6060610356848460008561035f565b90509392505050565b6060824710156103a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161039b90610c71565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516103cd9190610af4565b60006040518083038185875af1925050503d806000811461040a576040519150601f19603f3d011682016040523d82523d6000602084013e61040f565b606091505b50915091506104208783838761042c565b92505050949350505050565b6060831561048f5760008351141561048757610447856104a2565b610486576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161047d90610c91565b60405180910390fd5b5b82905061049a565b61049983836104c5565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156104d85781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050c9190610c4f565b60405180910390fd5b600061052861052384610cf6565b610cd1565b9050808382526020820190508285602086028201111561054b5761054a610f23565b5b60005b8581101561059957813567ffffffffffffffff81111561057157610570610f1e565b5b80860161057e89826106f0565b8552602085019450602084019350505060018101905061054e565b5050509392505050565b60006105b66105b184610d22565b610cd1565b905080838252602082019050828560208602820111156105d9576105d8610f23565b5b60005b8581101561060957816105ef888261071e565b8452602084019350602083019250506001810190506105dc565b5050509392505050565b600061062661062184610d4e565b610cd1565b90508281526020810184848401111561064257610641610f28565b5b61064d848285610e7c565b509392505050565b6000813590506106648161100f565b92915050565b600082601f83011261067f5761067e610f1e565b5b813561068f848260208601610515565b91505092915050565b600082601f8301126106ad576106ac610f1e565b5b81356106bd8482602086016105a3565b91505092915050565b6000813590506106d581611026565b92915050565b6000815190506106ea81611026565b92915050565b600082601f83011261070557610704610f1e565b5b8135610715848260208601610613565b91505092915050565b60008135905061072d8161103d565b92915050565b60008060006060848603121561074c5761074b610f32565b5b600084013567ffffffffffffffff81111561076a57610769610f2d565b5b6107768682870161066a565b935050602084013567ffffffffffffffff81111561079757610796610f2d565b5b6107a386828701610698565b92505060406107b4868287016106c6565b9150509250925092565b6000602082840312156107d4576107d3610f32565b5b60006107e2848285016106db565b91505092915050565b60008060006060848603121561080457610803610f32565b5b600084013567ffffffffffffffff81111561082257610821610f2d565b5b61082e868287016106f0565b935050602061083f8682870161071e565b9250506040610850868287016106c6565b9150509250925092565b60008060006060848603121561087357610872610f32565b5b60006108818682870161071e565b935050602061089286828701610655565b92505060406108a386828701610655565b9150509250925092565b60006108b983836109fb565b905092915050565b60006108cd8383610ad6565b60208301905092915050565b6108e281610e34565b82525050565b60006108f382610d9f565b6108fd8185610de5565b93508360208202850161090f85610d7f565b8060005b8581101561094b578484038952815161092c85826108ad565b945061093783610dcb565b925060208a01995050600181019050610913565b50829750879550505050505092915050565b600061096882610daa565b6109728185610df6565b935061097d83610d8f565b8060005b838110156109ae57815161099588826108c1565b97506109a083610dd8565b925050600181019050610981565b5085935050505092915050565b6109c481610e46565b82525050565b60006109d582610db5565b6109df8185610e07565b93506109ef818560208601610e8b565b80840191505092915050565b6000610a0682610dc0565b610a108185610e12565b9350610a20818560208601610e8b565b610a2981610f37565b840191505092915050565b6000610a3f82610dc0565b610a498185610e23565b9350610a59818560208601610e8b565b610a6281610f37565b840191505092915050565b6000610a7a602683610e23565b9150610a8582610f48565b604082019050919050565b6000610a9d601d83610e23565b9150610aa882610f97565b602082019050919050565b6000610ac0602a83610e23565b9150610acb82610fc0565b604082019050919050565b610adf81610e72565b82525050565b610aee81610e72565b82525050565b6000610b0082846109ca565b915081905092915050565b6000602082019050610b2060008301846108d9565b92915050565b6000606082019050610b3b60008301866108d9565b610b4860208301856108d9565b610b556040830184610ae5565b949350505050565b6000608082019050610b7260008301876108d9565b8181036020830152610b8481866108e8565b90508181036040830152610b98818561095d565b9050610ba760608301846109bb565b95945050505050565b6000608082019050610bc560008301876108d9565b610bd26020830186610ae5565b610bdf60408301856108d9565b610bec60608301846108d9565b95945050505050565b600060a082019050610c0a60008301886108d9565b610c176020830187610ae5565b8181036040830152610c298186610a34565b9050610c386060830185610ae5565b610c4560808301846109bb565b9695505050505050565b60006020820190508181036000830152610c698184610a34565b905092915050565b60006020820190508181036000830152610c8a81610a6d565b9050919050565b60006020820190508181036000830152610caa81610a90565b9050919050565b60006020820190508181036000830152610cca81610ab3565b9050919050565b6000610cdb610cec565b9050610ce78282610ebe565b919050565b6000604051905090565b600067ffffffffffffffff821115610d1157610d10610eef565b5b602082029050602081019050919050565b600067ffffffffffffffff821115610d3d57610d3c610eef565b5b602082029050602081019050919050565b600067ffffffffffffffff821115610d6957610d68610eef565b5b610d7282610f37565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000610e3f82610e52565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610ea9578082015181840152602081019050610e8e565b83811115610eb8576000848401525b50505050565b610ec782610f37565b810181811067ffffffffffffffff82111715610ee657610ee5610eef565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61101881610e34565b811461102357600080fd5b50565b61102f81610e46565b811461103a57600080fd5b50565b61104681610e72565b811461105157600080fd5b5056fea2646970667358221220086a1c9f56ed96506c7198d50cf431a5b03003c16cd4168d2395cdedfc1ac06164736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c612c726200024360003960008181610433015281816104c2015281816105d40152818161066301526107130152612c726000f3fe6080604052600436106100dd5760003560e01c80637993c1e01161007f578063bcf7f32b11610059578063bcf7f32b14610251578063c39aca371461027a578063f2fde38b146102a3578063f45346dc146102cc576100dd565b80637993c1e0146101e65780638129fc1c1461020f5780638da5cb5b14610226576100dd565b80633ce4a5bc116100bb5780633ce4a5bc1461015d5780634f1ef2861461018857806352d1902d146101a4578063715018a6146101cf576100dd565b80630ac7c44c146100e2578063135390f91461010b5780633659cfe614610134575b600080fd5b3480156100ee57600080fd5b5061010960048036038101906101049190611c80565b6102f5565b005b34801561011757600080fd5b50610132600480360381019061012d9190611cfc565b61034c565b005b34801561014057600080fd5b5061015b60048036038101906101569190611b0a565b610431565b005b34801561016957600080fd5b506101726105ba565b60405161017f919061226e565b60405180910390f35b6101a2600480360381019061019d9190611b37565b6105d2565b005b3480156101b057600080fd5b506101b961070f565b6040516101c691906122e9565b60405180910390f35b3480156101db57600080fd5b506101e46107c8565b005b3480156101f257600080fd5b5061020d60048036038101906102089190611d6b565b6107dc565b005b34801561021b57600080fd5b506102246108c7565b005b34801561023257600080fd5b5061023b610a0d565b604051610248919061226e565b60405180910390f35b34801561025d57600080fd5b5061027860048036038101906102739190611e0f565b610a37565b005b34801561028657600080fd5b506102a1600480360381019061029c9190611e0f565b610b2b565b005b3480156102af57600080fd5b506102ca60048036038101906102c59190611b0a565b610d5d565b005b3480156102d857600080fd5b506102f360048036038101906102ee9190611bd3565b610de1565b005b3373ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f84848460405161033f93929190612304565b60405180910390a2505050565b60006103588383610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8585848673ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156103db57600080fd5b505afa1580156103ef573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104139190611ec5565b60405161042394939291906123a0565b60405180910390a250505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156104c0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104b79061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166104ff61128d565b73ffffffffffffffffffffffffffffffffffffffff1614610555576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161054c9061247c565b60405180910390fd5b61055e816112e4565b6105b781600067ffffffffffffffff81111561057d5761057c61282b565b5b6040519080825280601f01601f1916602001820160405280156105af5781602001600182028036833780820191505090505b5060006112ef565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610661576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106589061245c565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106a061128d565b73ffffffffffffffffffffffffffffffffffffffff16146106f6576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106ed9061247c565b60405180910390fd5b6106ff826112e4565b61070b828260016112ef565b5050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161461079f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107969061249c565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b6107d061146c565b6107da60006114ea565b565b60006107e88585610f9d565b90503373ffffffffffffffffffffffffffffffffffffffff167f1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d8787848873ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561086b57600080fd5b505afa15801561087f573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108a39190611ec5565b88886040516108b79695949392919061233d565b60405180910390a2505050505050565b60008060019054906101000a900460ff161590508080156108f85750600160008054906101000a900460ff1660ff16105b806109255750610907306115b0565b1580156109245750600160008054906101000a900460ff1660ff16145b5b610964576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161095b906124dc565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109a1576001600060016101000a81548160ff0219169083151502179055505b6109a96115d3565b6109b161162c565b8015610a0a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610a0191906123ff565b60405180910390a15b50565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ab0576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610af195949392919061259c565b600060405180830381600087803b158015610b0b57600080fd5b505af1158015610b1f573d6000803e3d6000fd5b50505050505050505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ba4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161480610c1d57503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610c54576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610c8f9291906122c0565b602060405180830381600087803b158015610ca957600080fd5b505af1158015610cbd573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ce19190611c26565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610d2395949392919061259c565b600060405180830381600087803b158015610d3d57600080fd5b505af1158015610d51573d6000803e3d6000fd5b50505050505050505050565b610d6561146c565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610dd5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610dcc9061243c565b60405180910390fd5b610dde816114ea565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610e5a576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161480610ed357503073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15610f0a576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff166347e7ef2482846040518363ffffffff1660e01b8152600401610f459291906122c0565b602060405180830381600087803b158015610f5f57600080fd5b505af1158015610f73573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f979190611c26565b50505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1663d9eeebed6040518163ffffffff1660e01b8152600401604080518083038186803b158015610fe757600080fd5b505afa158015610ffb573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061101f9190611b93565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b815260040161107493929190612289565b602060405180830381600087803b15801561108e57600080fd5b505af11580156110a2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906110c69190611c26565b6110fc576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166323b872dd3330886040518463ffffffff1660e01b815260040161113993929190612289565b602060405180830381600087803b15801561115357600080fd5b505af1158015611167573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061118b9190611c26565b6111c1576040517f4dd9ee8d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166342966c68866040518263ffffffff1660e01b81526004016111fa91906125f1565b602060405180830381600087803b15801561121457600080fd5b505af1158015611228573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061124c9190611c26565b611282576040517f2c77e05c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b809250505092915050565b60006112bb7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6112ec61146c565b50565b61131b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611687565b60000160009054906101000a900460ff161561133f5761133a83611691565b611467565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561138557600080fd5b505afa9250505080156113b657506040513d601f19601f820116820180604052508101906113b39190611c53565b60015b6113f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113ec906124fc565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b811461145a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611451906124bc565b60405180910390fd5b5061146683838361174a565b5b505050565b611474611776565b73ffffffffffffffffffffffffffffffffffffffff16611492610a0d565b73ffffffffffffffffffffffffffffffffffffffff16146114e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016114df9061253c565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611622576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116199061257c565b60405180910390fd5b61162a61177e565b565b600060019054906101000a900460ff1661167b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116729061257c565b60405180910390fd5b565b6000819050919050565b6000819050919050565b61169a816115b0565b6116d9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116d09061251c565b60405180910390fd5b806117067f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b61167d565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611753836117df565b6000825111806117605750805b156117715761176f838361182e565b505b505050565b600033905090565b600060019054906101000a900460ff166117cd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117c49061257c565b60405180910390fd5b6117dd6117d8611776565b6114ea565b565b6117e881611691565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60606118538383604051806060016040528060278152602001612c166027913961185b565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516118859190612257565b600060405180830381855af49150503d80600081146118c0576040519150601f19603f3d011682016040523d82523d6000602084013e6118c5565b606091505b50915091506118d6868383876118e1565b925050509392505050565b606083156119445760008351141561193c576118fc856115b0565b61193b576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119329061255c565b60405180910390fd5b5b82905061194f565b61194e8383611957565b5b949350505050565b60008251111561196a5781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161199e919061241a565b60405180910390fd5b60006119ba6119b584612631565b61260c565b9050828152602081018484840111156119d6576119d5612878565b5b6119e18482856127b8565b509392505050565b6000813590506119f881612bb9565b92915050565b600081519050611a0d81612bb9565b92915050565b600081519050611a2281612bd0565b92915050565b600081519050611a3781612be7565b92915050565b60008083601f840112611a5357611a52612864565b5b8235905067ffffffffffffffff811115611a7057611a6f61285f565b5b602083019150836001820283011115611a8c57611a8b612873565b5b9250929050565b600082601f830112611aa857611aa7612864565b5b8135611ab88482602086016119a7565b91505092915050565b600060608284031215611ad757611ad6612869565b5b81905092915050565b600081359050611aef81612bfe565b92915050565b600081519050611b0481612bfe565b92915050565b600060208284031215611b2057611b1f612887565b5b6000611b2e848285016119e9565b91505092915050565b60008060408385031215611b4e57611b4d612887565b5b6000611b5c858286016119e9565b925050602083013567ffffffffffffffff811115611b7d57611b7c61287d565b5b611b8985828601611a93565b9150509250929050565b60008060408385031215611baa57611ba9612887565b5b6000611bb8858286016119fe565b9250506020611bc985828601611af5565b9150509250929050565b600080600060608486031215611bec57611beb612887565b5b6000611bfa868287016119e9565b9350506020611c0b86828701611ae0565b9250506040611c1c868287016119e9565b9150509250925092565b600060208284031215611c3c57611c3b612887565b5b6000611c4a84828501611a13565b91505092915050565b600060208284031215611c6957611c68612887565b5b6000611c7784828501611a28565b91505092915050565b600080600060408486031215611c9957611c98612887565b5b600084013567ffffffffffffffff811115611cb757611cb661287d565b5b611cc386828701611a93565b935050602084013567ffffffffffffffff811115611ce457611ce361287d565b5b611cf086828701611a3d565b92509250509250925092565b600080600060608486031215611d1557611d14612887565b5b600084013567ffffffffffffffff811115611d3357611d3261287d565b5b611d3f86828701611a93565b9350506020611d5086828701611ae0565b9250506040611d61868287016119e9565b9150509250925092565b600080600080600060808688031215611d8757611d86612887565b5b600086013567ffffffffffffffff811115611da557611da461287d565b5b611db188828901611a93565b9550506020611dc288828901611ae0565b9450506040611dd3888289016119e9565b935050606086013567ffffffffffffffff811115611df457611df361287d565b5b611e0088828901611a3d565b92509250509295509295909350565b60008060008060008060a08789031215611e2c57611e2b612887565b5b600087013567ffffffffffffffff811115611e4a57611e4961287d565b5b611e5689828a01611ac1565b9650506020611e6789828a016119e9565b9550506040611e7889828a01611ae0565b9450506060611e8989828a016119e9565b935050608087013567ffffffffffffffff811115611eaa57611ea961287d565b5b611eb689828a01611a3d565b92509250509295509295509295565b600060208284031215611edb57611eda612887565b5b6000611ee984828501611af5565b91505092915050565b611efb81612747565b82525050565b611f0a81612747565b82525050565b611f1981612765565b82525050565b6000611f2b8385612678565b9350611f388385846127b8565b611f418361288c565b840190509392505050565b6000611f588385612689565b9350611f658385846127b8565b611f6e8361288c565b840190509392505050565b6000611f8482612662565b611f8e8185612689565b9350611f9e8185602086016127c7565b611fa78161288c565b840191505092915050565b6000611fbd82612662565b611fc7818561269a565b9350611fd78185602086016127c7565b80840191505092915050565b611fec816127a6565b82525050565b6000611ffd8261266d565b61200781856126a5565b93506120178185602086016127c7565b6120208161288c565b840191505092915050565b60006120386026836126a5565b91506120438261289d565b604082019050919050565b600061205b602c836126a5565b9150612066826128ec565b604082019050919050565b600061207e602c836126a5565b91506120898261293b565b604082019050919050565b60006120a16038836126a5565b91506120ac8261298a565b604082019050919050565b60006120c46029836126a5565b91506120cf826129d9565b604082019050919050565b60006120e7602e836126a5565b91506120f282612a28565b604082019050919050565b600061210a602e836126a5565b915061211582612a77565b604082019050919050565b600061212d602d836126a5565b915061213882612ac6565b604082019050919050565b60006121506020836126a5565b915061215b82612b15565b602082019050919050565b6000612173600083612689565b915061217e82612b3e565b600082019050919050565b6000612196601d836126a5565b91506121a182612b41565b602082019050919050565b60006121b9602b836126a5565b91506121c482612b6a565b604082019050919050565b6000606083016121e260008401846126cd565b85830360008701526121f5838284611f1f565b9250505061220660208401846126b6565b6122136020860182611ef2565b506122216040840184612730565b61222e6040860182612239565b508091505092915050565b6122428161278f565b82525050565b6122518161278f565b82525050565b60006122638284611fb2565b915081905092915050565b60006020820190506122836000830184611f01565b92915050565b600060608201905061229e6000830186611f01565b6122ab6020830185611f01565b6122b86040830184612248565b949350505050565b60006040820190506122d56000830185611f01565b6122e26020830184612248565b9392505050565b60006020820190506122fe6000830184611f10565b92915050565b6000604082019050818103600083015261231e8186611f79565b90508181036020830152612333818486611f4c565b9050949350505050565b600060a08201905081810360008301526123578189611f79565b90506123666020830188612248565b6123736040830187612248565b6123806060830186612248565b8181036080830152612393818486611f4c565b9050979650505050505050565b600060a08201905081810360008301526123ba8187611f79565b90506123c96020830186612248565b6123d66040830185612248565b6123e36060830184612248565b81810360808301526123f481612166565b905095945050505050565b60006020820190506124146000830184611fe3565b92915050565b600060208201905081810360008301526124348184611ff2565b905092915050565b600060208201905081810360008301526124558161202b565b9050919050565b600060208201905081810360008301526124758161204e565b9050919050565b6000602082019050818103600083015261249581612071565b9050919050565b600060208201905081810360008301526124b581612094565b9050919050565b600060208201905081810360008301526124d5816120b7565b9050919050565b600060208201905081810360008301526124f5816120da565b9050919050565b60006020820190508181036000830152612515816120fd565b9050919050565b6000602082019050818103600083015261253581612120565b9050919050565b6000602082019050818103600083015261255581612143565b9050919050565b6000602082019050818103600083015261257581612189565b9050919050565b60006020820190508181036000830152612595816121ac565b9050919050565b600060808201905081810360008301526125b681886121cf565b90506125c56020830187611f01565b6125d26040830186612248565b81810360608301526125e5818486611f4c565b90509695505050505050565b60006020820190506126066000830184612248565b92915050565b6000612616612627565b905061262282826127fa565b919050565b6000604051905090565b600067ffffffffffffffff82111561264c5761264b61282b565b5b6126558261288c565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006126c560208401846119e9565b905092915050565b600080833560016020038436030381126126ea576126e9612882565b5b83810192508235915060208301925067ffffffffffffffff8211156127125761271161285a565b5b6001820236038413156127285761272761286e565b5b509250929050565b600061273f6020840184611ae0565b905092915050565b60006127528261276f565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006127b182612799565b9050919050565b82818337600083830152505050565b60005b838110156127e55780820151818401526020810190506127ca565b838111156127f4576000848401525b50505050565b6128038261288c565b810181811067ffffffffffffffff821117156128225761282161282b565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b612bc281612747565b8114612bcd57600080fd5b50565b612bd981612759565b8114612be457600080fd5b50565b612bf081612765565b8114612bfb57600080fd5b50565b612c078161278f565b8114612c1257600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a264697066735822122015c949adac746922ae292180700af4f4a4ce97a3db9d7b2c84f6c7beb1452aaa64736f6c63430008070033608060405234801561001057600080fd5b50604051610bcd380380610bcd8339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610ab6806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105fd565b61009c565b005b61006a6102af565b6040516100779190610761565b60405180910390f35b61009a6004803603810190610095919061055e565b6102d3565b005b60008383836040516024016100b39392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d92919061077c565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df9190610531565b610215576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161027494939291906107dc565b600060405180830381600087803b15801561028e57600080fd5b505af11580156102a2573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102ea9392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b81526004016103c49291906107a5565b600060405180830381600087803b1580156103de57600080fd5b505af11580156103f2573d6000803e3d6000fd5b505050505050505050565b600061041061040b84610892565b61086d565b90508281526020810184848401111561042c5761042b610a1b565b5b610437848285610974565b509392505050565b600061045261044d846108c3565b61086d565b90508281526020810184848401111561046e5761046d610a1b565b5b610479848285610974565b509392505050565b60008135905061049081610a3b565b92915050565b6000813590506104a581610a52565b92915050565b6000815190506104ba81610a52565b92915050565b600082601f8301126104d5576104d4610a16565b5b81356104e58482602086016103fd565b91505092915050565b600082601f83011261050357610502610a16565b5b813561051384826020860161043f565b91505092915050565b60008135905061052b81610a69565b92915050565b60006020828403121561054757610546610a25565b5b6000610555848285016104ab565b91505092915050565b6000806000806080858703121561057857610577610a25565b5b600085013567ffffffffffffffff81111561059657610595610a20565b5b6105a2878288016104c0565b945050602085013567ffffffffffffffff8111156105c3576105c2610a20565b5b6105cf878288016104ee565b93505060406105e08782880161051c565b92505060606105f187828801610496565b91505092959194509250565b60008060008060008060c0878903121561061a57610619610a25565b5b600087013567ffffffffffffffff81111561063857610637610a20565b5b61064489828a016104c0565b965050602061065589828a0161051c565b955050604061066689828a01610481565b945050606087013567ffffffffffffffff81111561068757610686610a20565b5b61069389828a016104ee565b93505060806106a489828a0161051c565b92505060a06106b589828a01610496565b9150509295509295509295565b6106cb8161092c565b82525050565b6106da8161093e565b82525050565b60006106eb826108f4565b6106f5818561090a565b9350610705818560208601610983565b61070e81610a2a565b840191505092915050565b6000610724826108ff565b61072e818561091b565b935061073e818560208601610983565b61074781610a2a565b840191505092915050565b61075b8161096a565b82525050565b600060208201905061077660008301846106c2565b92915050565b600060408201905061079160008301856106c2565b61079e6020830184610752565b9392505050565b600060408201905081810360008301526107bf81856106e0565b905081810360208301526107d381846106e0565b90509392505050565b600060808201905081810360008301526107f681876106e0565b90506108056020830186610752565b61081260408301856106c2565b818103606083015261082481846106e0565b905095945050505050565b600060608201905081810360008301526108498186610719565b90506108586020830185610752565b61086560408301846106d1565b949350505050565b6000610877610888565b905061088382826109b6565b919050565b6000604051905090565b600067ffffffffffffffff8211156108ad576108ac6109e7565b5b6108b682610a2a565b9050602081019050919050565b600067ffffffffffffffff8211156108de576108dd6109e7565b5b6108e782610a2a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b60006109378261094a565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156109a1578082015181840152602081019050610986565b838111156109b0576000848401525b50505050565b6109bf82610a2a565b810181811067ffffffffffffffff821117156109de576109dd6109e7565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a448161092c565b8114610a4f57600080fd5b50565b610a5b8161093e565b8114610a6657600080fd5b50565b610a728161096a565b8114610a7d57600080fd5b5056fea26469706673582212205b143977db6155828f5d21dccf3e39e1abbc3e6abfa0cfb9b988a47a7ff289c864736f6c6343000807003360806040523480156200001157600080fd5b50604051620010d7380380620010d7833981810160405281019062000037919062000146565b82600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507f80699e81136d69cb8367ad52a994e25c722a86da654b561d0c14b61a777e7ac560405160405180910390a1505050620001f5565b6000815190506200014081620001db565b92915050565b600080600060608486031215620001625762000161620001d6565b5b600062000172868287016200012f565b935050602062000185868287016200012f565b925050604062000198868287016200012f565b9150509250925092565b6000620001af82620001b6565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b620001e681620001a2565b8114620001f257600080fd5b50565b610ed280620002056000396000f3fe608060405234801561001057600080fd5b50600436106100a95760003560e01c806397770dff1161007157806397770dff14610166578063a7cb050714610182578063c63585cc1461019e578063d7fd7afb146101ce578063d936a012146101fe578063ee2815ba1461021c576100a9565b80630be15547146100ae5780633c669d55146100de578063513a9c05146100fa578063569541b91461012a578063842da36d14610148575b600080fd5b6100c860048036038101906100c3919061094d565b610238565b6040516100d59190610bce565b60405180910390f35b6100f860048036038101906100f39190610898565b61026b565b005b610114600480360381019061010f919061094d565b6103b8565b6040516101219190610bce565b60405180910390f35b6101326103eb565b60405161013f9190610bce565b60405180910390f35b610150610411565b60405161015d9190610bce565b60405180910390f35b610180600480360381019061017b9190610818565b610437565b005b61019c600480360381019061019791906109ba565b6104d4565b005b6101b860048036038101906101b39190610845565b610528565b6040516101c59190610bce565b60405180910390f35b6101e860048036038101906101e3919061094d565b61059a565b6040516101f59190610c67565b60405180910390f35b6102066105b2565b6040516102139190610bce565b60405180910390f35b6102366004803603810190610231919061097a565b6105d8565b005b60016020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600060405180606001604052806040518060200160405280600081525081526020013373ffffffffffffffffffffffffffffffffffffffff1681526020014681525090508473ffffffffffffffffffffffffffffffffffffffff1663a9059cbb87866040518363ffffffff1660e01b81526004016102ea929190610be9565b602060405180830381600087803b15801561030457600080fd5b505af1158015610318573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061033c9190610920565b508573ffffffffffffffffffffffffffffffffffffffff1663de43156e82878787876040518663ffffffff1660e01b815260040161037e959493929190610c12565b600060405180830381600087803b15801561039857600080fd5b505af11580156103ac573d6000803e3d6000fd5b50505050505050505050565b60026020528060005260406000206000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b80600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fdba79d534382d1a8ae108e4c8ecb27c6ae42ab8b91d44eedf88bd329f3868d5e600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516104c99190610bce565b60405180910390a150565b80600080848152602001908152602001600020819055507f49f492222906ac486c3c1401fa545626df1f0c0e5a77a05597ea2ed66af9850d828260405161051c929190610cab565b60405180910390a15050565b60008060006105378585610667565b9150915085828260405160200161054f929190610b60565b60405160208183030381529060405280519060200120604051602001610576929190610b8c565b6040516020818303038152906040528051906020012060001c925050509392505050565b60006020528060005260406000206000915090505481565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b806001600084815260200190815260200160002060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd1b36d30f6248e97c473b4d1348ca164a4ef6759022f54a58ec200326c39c45d828260405161065b929190610c82565b60405180910390a15050565b6000808273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156106d0576040517fcb1e7cfe00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161061070a57828461070d565b83835b8092508193505050600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561077c576040517f78b507da00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b9250929050565b60008135905061079281610e57565b92915050565b6000815190506107a781610e6e565b92915050565b60008083601f8401126107c3576107c2610dd3565b5b8235905067ffffffffffffffff8111156107e0576107df610dce565b5b6020830191508360018202830111156107fc576107fb610dd8565b5b9250929050565b60008135905061081281610e85565b92915050565b60006020828403121561082e5761082d610de2565b5b600061083c84828501610783565b91505092915050565b60008060006060848603121561085e5761085d610de2565b5b600061086c86828701610783565b935050602061087d86828701610783565b925050604061088e86828701610783565b9150509250925092565b6000806000806000608086880312156108b4576108b3610de2565b5b60006108c288828901610783565b95505060206108d388828901610783565b94505060406108e488828901610803565b935050606086013567ffffffffffffffff81111561090557610904610ddd565b5b610911888289016107ad565b92509250509295509295909350565b60006020828403121561093657610935610de2565b5b600061094484828501610798565b91505092915050565b60006020828403121561096357610962610de2565b5b600061097184828501610803565b91505092915050565b6000806040838503121561099157610990610de2565b5b600061099f85828601610803565b92505060206109b085828601610783565b9150509250929050565b600080604083850312156109d1576109d0610de2565b5b60006109df85828601610803565b92505060206109f085828601610803565b9150509250929050565b610a0381610d0c565b82525050565b610a1281610d0c565b82525050565b610a29610a2482610d0c565b610da0565b82525050565b610a40610a3b82610d2a565b610db2565b82525050565b6000610a528385610cf0565b9350610a5f838584610d5e565b610a6883610de7565b840190509392505050565b6000610a7e82610cd4565b610a888185610cdf565b9350610a98818560208601610d6d565b610aa181610de7565b840191505092915050565b6000610ab9602083610d01565b9150610ac482610e05565b602082019050919050565b6000610adc600183610d01565b9150610ae782610e2e565b600182019050919050565b60006060830160008301518482036000860152610b0f8282610a73565b9150506020830151610b2460208601826109fa565b506040830151610b376040860182610b42565b508091505092915050565b610b4b81610d54565b82525050565b610b5a81610d54565b82525050565b6000610b6c8285610a18565b601482019150610b7c8284610a18565b6014820191508190509392505050565b6000610b9782610acf565b9150610ba38285610a18565b601482019150610bb38284610a2f565b602082019150610bc282610aac565b91508190509392505050565b6000602082019050610be36000830184610a09565b92915050565b6000604082019050610bfe6000830185610a09565b610c0b6020830184610b51565b9392505050565b60006080820190508181036000830152610c2c8188610af2565b9050610c3b6020830187610a09565b610c486040830186610b51565b8181036060830152610c5b818486610a46565b90509695505050505050565b6000602082019050610c7c6000830184610b51565b92915050565b6000604082019050610c976000830185610b51565b610ca46020830184610a09565b9392505050565b6000604082019050610cc06000830185610b51565b610ccd6020830184610b51565b9392505050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b6000610d1782610d34565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b83811015610d8b578082015181840152602081019050610d70565b83811115610d9a576000848401525b50505050565b6000610dab82610dbc565b9050919050565b6000819050919050565b6000610dc782610df8565b9050919050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f600082015250565b7fff00000000000000000000000000000000000000000000000000000000000000600082015250565b610e6081610d0c565b8114610e6b57600080fd5b50565b610e7781610d1e565b8114610e8257600080fd5b50565b610e8e81610d54565b8114610e9957600080fd5b5056fea26469706673582212202a32df31a933796903f60b841b0f44768ba91c1035d163fc0f04fe249f5f2e7464736f6c6343000807003360c06040523480156200001157600080fd5b506040516200282d3803806200282d83398181016040528101906200003791906200035b565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614620000b1576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8760079080519060200190620000c9929190620001d1565b508660089080519060200190620000e2929190620001d1565b5085600960006101000a81548160ff021916908360ff16021790555084608081815250508360028111156200011c576200011b620005ae565b5b60a0816002811115620001345762000133620005ae565b5b60f81b8152505082600281905550816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050505050505050620006bf565b828054620001df9062000542565b90600052602060002090601f0160209004810192826200020357600085556200024f565b82601f106200021e57805160ff19168380011785556200024f565b828001600101855582156200024f579182015b828111156200024e57825182559160200191906001019062000231565b5b5090506200025e919062000262565b5090565b5b808211156200027d57600081600090555060010162000263565b5090565b60006200029862000292846200048b565b62000462565b905082815260208101848484011115620002b757620002b662000640565b5b620002c48482856200050c565b509392505050565b600081519050620002dd8162000660565b92915050565b600081519050620002f4816200067a565b92915050565b600082601f8301126200031257620003116200063b565b5b81516200032484826020860162000281565b91505092915050565b6000815190506200033e816200068b565b92915050565b6000815190506200035581620006a5565b92915050565b600080600080600080600080610100898b0312156200037f576200037e6200064a565b5b600089015167ffffffffffffffff811115620003a0576200039f62000645565b5b620003ae8b828c01620002fa565b985050602089015167ffffffffffffffff811115620003d257620003d162000645565b5b620003e08b828c01620002fa565b9750506040620003f38b828c0162000344565b9650506060620004068b828c016200032d565b9550506080620004198b828c01620002e3565b94505060a06200042c8b828c016200032d565b93505060c06200043f8b828c01620002cc565b92505060e0620004528b828c01620002cc565b9150509295985092959890939650565b60006200046e62000481565b90506200047c828262000578565b919050565b6000604051905090565b600067ffffffffffffffff821115620004a957620004a86200060c565b5b620004b4826200064f565b9050602081019050919050565b6000620004ce82620004d5565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b838110156200052c5780820151818401526020810190506200050f565b838111156200053c576000848401525b50505050565b600060028204905060018216806200055b57607f821691505b60208210811415620005725762000571620005dd565b5b50919050565b62000583826200064f565b810181811067ffffffffffffffff82111715620005a557620005a46200060c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b6200066b81620004c1565b81146200067757600080fd5b50565b600381106200068857600080fd5b50565b6200069681620004f5565b8114620006a257600080fd5b50565b620006b081620004ff565b8114620006bc57600080fd5b50565b60805160a05160f81c612137620006f660003960006109580152600081816108a201528181610c250152610d5a01526121376000f3fe608060405234801561001057600080fd5b506004361061014d5760003560e01c806385e1f4d0116100c3578063d9eeebed1161007c578063d9eeebed146103cc578063dd62ed3e146103eb578063e2f535b81461041b578063eddeb12314610439578063f2441b3214610455578063f687d12a146104735761014d565b806385e1f4d0146102f657806395d89b4114610314578063a3413d0314610332578063a9059cbb14610350578063c701262614610380578063c835d7cc146103b05761014d565b8063313ce56711610115578063313ce5671461020c5780633ce4a5bc1461022a57806342966c681461024857806347e7ef24146102785780634d8943bb146102a857806370a08231146102c65761014d565b806306fdde0314610152578063091d278814610170578063095ea7b31461018e57806318160ddd146101be57806323b872dd146101dc575b600080fd5b61015a61048f565b6040516101679190611cad565b60405180910390f35b610178610521565b6040516101859190611ccf565b60405180910390f35b6101a860048036038101906101a3919061196e565b610527565b6040516101b59190611bfb565b60405180910390f35b6101c6610545565b6040516101d39190611ccf565b60405180910390f35b6101f660048036038101906101f1919061191b565b61054f565b6040516102039190611bfb565b60405180910390f35b610214610647565b6040516102219190611cea565b60405180910390f35b61023261065e565b60405161023f9190611b80565b60405180910390f35b610262600480360381019061025d9190611a37565b610676565b60405161026f9190611bfb565b60405180910390f35b610292600480360381019061028d919061196e565b61068b565b60405161029f9190611bfb565b60405180910390f35b6102b0610851565b6040516102bd9190611ccf565b60405180910390f35b6102e060048036038101906102db9190611881565b610857565b6040516102ed9190611ccf565b60405180910390f35b6102fe6108a0565b60405161030b9190611ccf565b60405180910390f35b61031c6108c4565b6040516103299190611cad565b60405180910390f35b61033a610956565b6040516103479190611c92565b60405180910390f35b61036a6004803603810190610365919061196e565b61097a565b6040516103779190611bfb565b60405180910390f35b61039a600480360381019061039591906119db565b610998565b6040516103a79190611bfb565b60405180910390f35b6103ca60048036038101906103c59190611881565b610aee565b005b6103d4610be1565b6040516103e2929190611bd2565b60405180910390f35b610405600480360381019061040091906118db565b610e4e565b6040516104129190611ccf565b60405180910390f35b610423610ed5565b6040516104309190611b80565b60405180910390f35b610453600480360381019061044e9190611a37565b610efb565b005b61045d610fb5565b60405161046a9190611b80565b60405180910390f35b61048d60048036038101906104889190611a37565b610fd9565b005b60606007805461049e90611f33565b80601f01602080910402602001604051908101604052809291908181526020018280546104ca90611f33565b80156105175780601f106104ec57610100808354040283529160200191610517565b820191906000526020600020905b8154815290600101906020018083116104fa57829003601f168201915b5050505050905090565b60025481565b600061053b610534611093565b848461109b565b6001905092915050565b6000600654905090565b600061055c848484611254565b6000600560008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006105a7611093565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205490508281101561061e576040517f10bad14700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61063b8561062a611093565b85846106369190611e43565b61109b565b60019150509392505050565b6000600960009054906101000a900460ff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b600061068233836114b0565b60019050919050565b600073735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614158015610729575060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614155b80156107835750600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614155b156107ba576040517fddb5de5e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6107c48383611668565b8273ffffffffffffffffffffffffffffffffffffffff167f67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab373735b14bb79463307aacbed86daf3322b1e6226ab6040516020016108219190611b65565b6040516020818303038152906040528460405161083f929190611c16565b60405180910390a26001905092915050565b60035481565b6000600460008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b7f000000000000000000000000000000000000000000000000000000000000000081565b6060600880546108d390611f33565b80601f01602080910402602001604051908101604052809291908181526020018280546108ff90611f33565b801561094c5780601f106109215761010080835404028352916020019161094c565b820191906000526020600020905b81548152906001019060200180831161092f57829003601f168201915b5050505050905090565b7f000000000000000000000000000000000000000000000000000000000000000081565b600061098e610987611093565b8484611254565b6001905092915050565b60008060006109a5610be1565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b81526004016109fa93929190611b9b565b602060405180830381600087803b158015610a1457600080fd5b505af1158015610a28573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610a4c91906119ae565b610a82576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610a8c33856114b0565b3373ffffffffffffffffffffffffffffffffffffffff167f9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955868684600354604051610ada9493929190611c46565b60405180910390a260019250505092915050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610b67576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae81604051610bd69190611b80565b60405180910390a150565b60008060008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630be155477f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610c609190611ccf565b60206040518083038186803b158015610c7857600080fd5b505afa158015610c8c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cb091906118ae565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610d19576040517f78fff39600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d7fd7afb7f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610d959190611ccf565b60206040518083038186803b158015610dad57600080fd5b505afa158015610dc1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610de59190611a64565b90506000811415610e22576040517fe661aed000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060035460025483610e359190611de9565b610e3f9190611d93565b90508281945094505050509091565b6000600560008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610f74576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806003819055507fef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f81604051610faa9190611ccf565b60405180910390a150565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611052576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806002819055507fff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a816040516110889190611ccf565b60405180910390a150565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611102576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611169576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040516112479190611ccf565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156112bb576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611322576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156113a0576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816113ac9190611e43565b600460008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825461143e9190611d93565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516114a29190611ccf565b60405180910390a350505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611517576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905081811015611595576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816115a19190611e43565b600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600660008282546115f69190611e43565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8460405161165b9190611ccf565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116cf576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600660008282546116e19190611d93565b9250508190555080600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546117379190611d93565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef8360405161179c9190611ccf565b60405180910390a35050565b60006117bb6117b684611d2a565b611d05565b9050828152602081018484840111156117d7576117d661207b565b5b6117e2848285611ef1565b509392505050565b6000813590506117f9816120bc565b92915050565b60008151905061180e816120bc565b92915050565b600081519050611823816120d3565b92915050565b600082601f83011261183e5761183d612076565b5b813561184e8482602086016117a8565b91505092915050565b600081359050611866816120ea565b92915050565b60008151905061187b816120ea565b92915050565b60006020828403121561189757611896612085565b5b60006118a5848285016117ea565b91505092915050565b6000602082840312156118c4576118c3612085565b5b60006118d2848285016117ff565b91505092915050565b600080604083850312156118f2576118f1612085565b5b6000611900858286016117ea565b9250506020611911858286016117ea565b9150509250929050565b60008060006060848603121561193457611933612085565b5b6000611942868287016117ea565b9350506020611953868287016117ea565b925050604061196486828701611857565b9150509250925092565b6000806040838503121561198557611984612085565b5b6000611993858286016117ea565b92505060206119a485828601611857565b9150509250929050565b6000602082840312156119c4576119c3612085565b5b60006119d284828501611814565b91505092915050565b600080604083850312156119f2576119f1612085565b5b600083013567ffffffffffffffff811115611a1057611a0f612080565b5b611a1c85828601611829565b9250506020611a2d85828601611857565b9150509250929050565b600060208284031215611a4d57611a4c612085565b5b6000611a5b84828501611857565b91505092915050565b600060208284031215611a7a57611a79612085565b5b6000611a888482850161186c565b91505092915050565b611a9a81611e77565b82525050565b611ab1611aac82611e77565b611f96565b82525050565b611ac081611e89565b82525050565b6000611ad182611d5b565b611adb8185611d71565b9350611aeb818560208601611f00565b611af48161208a565b840191505092915050565b611b0881611edf565b82525050565b6000611b1982611d66565b611b238185611d82565b9350611b33818560208601611f00565b611b3c8161208a565b840191505092915050565b611b5081611ec8565b82525050565b611b5f81611ed2565b82525050565b6000611b718284611aa0565b60148201915081905092915050565b6000602082019050611b956000830184611a91565b92915050565b6000606082019050611bb06000830186611a91565b611bbd6020830185611a91565b611bca6040830184611b47565b949350505050565b6000604082019050611be76000830185611a91565b611bf46020830184611b47565b9392505050565b6000602082019050611c106000830184611ab7565b92915050565b60006040820190508181036000830152611c308185611ac6565b9050611c3f6020830184611b47565b9392505050565b60006080820190508181036000830152611c608187611ac6565b9050611c6f6020830186611b47565b611c7c6040830185611b47565b611c896060830184611b47565b95945050505050565b6000602082019050611ca76000830184611aff565b92915050565b60006020820190508181036000830152611cc78184611b0e565b905092915050565b6000602082019050611ce46000830184611b47565b92915050565b6000602082019050611cff6000830184611b56565b92915050565b6000611d0f611d20565b9050611d1b8282611f65565b919050565b6000604051905090565b600067ffffffffffffffff821115611d4557611d44612047565b5b611d4e8261208a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b6000611d9e82611ec8565b9150611da983611ec8565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115611dde57611ddd611fba565b5b828201905092915050565b6000611df482611ec8565b9150611dff83611ec8565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615611e3857611e37611fba565b5b828202905092915050565b6000611e4e82611ec8565b9150611e5983611ec8565b925082821015611e6c57611e6b611fba565b5b828203905092915050565b6000611e8282611ea8565b9050919050565b60008115159050919050565b6000819050611ea3826120a8565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000611eea82611e95565b9050919050565b82818337600083830152505050565b60005b83811015611f1e578082015181840152602081019050611f03565b83811115611f2d576000848401525b50505050565b60006002820490506001821680611f4b57607f821691505b60208210811415611f5f57611f5e612018565b5b50919050565b611f6e8261208a565b810181811067ffffffffffffffff82111715611f8d57611f8c612047565b5b80604052505050565b6000611fa182611fa8565b9050919050565b6000611fb38261209b565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b600381106120b9576120b8611fe9565b5b50565b6120c581611e77565b81146120d057600080fd5b50565b6120dc81611e89565b81146120e757600080fd5b50565b6120f381611ec8565b81146120fe57600080fd5b5056fea26469706673582212204256743d8281ef8d828896d1bab08cb03656cd913941f2ab189ea466016eead564736f6c63430008070033a264697066735822122061a51f9afd0e3be660d02e15aa3ec2c11dcb8b25643f9be51d4c39275da350c064736f6c63430008070033", +// GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. +var GatewayEVMZEVMTestMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } -// GatewayIntegrationTestABI is the input ABI used to generate the binding from. -// Deprecated: Use GatewayIntegrationTestMetaData.ABI instead. -var GatewayIntegrationTestABI = GatewayIntegrationTestMetaData.ABI +// GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. +// Deprecated: Use GatewayEVMZEVMTestMetaData.ABI instead. +var GatewayEVMZEVMTestABI = GatewayEVMZEVMTestMetaData.ABI -// GatewayIntegrationTestBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use GatewayIntegrationTestMetaData.Bin instead. -var GatewayIntegrationTestBin = GatewayIntegrationTestMetaData.Bin +// GatewayEVMZEVMTestBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use GatewayEVMZEVMTestMetaData.Bin instead. +var GatewayEVMZEVMTestBin = GatewayEVMZEVMTestMetaData.Bin -// DeployGatewayIntegrationTest deploys a new Ethereum contract, binding an instance of GatewayIntegrationTest to it. -func DeployGatewayIntegrationTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayIntegrationTest, error) { - parsed, err := GatewayIntegrationTestMetaData.GetAbi() +// DeployGatewayEVMZEVMTest deploys a new Ethereum contract, binding an instance of GatewayEVMZEVMTest to it. +func DeployGatewayEVMZEVMTest(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *GatewayEVMZEVMTest, error) { + parsed, err := GatewayEVMZEVMTestMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } @@ -71,111 +71,111 @@ func DeployGatewayIntegrationTest(auth *bind.TransactOpts, backend bind.Contract return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayIntegrationTestBin), backend) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(GatewayEVMZEVMTestBin), backend) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &GatewayIntegrationTest{GatewayIntegrationTestCaller: GatewayIntegrationTestCaller{contract: contract}, GatewayIntegrationTestTransactor: GatewayIntegrationTestTransactor{contract: contract}, GatewayIntegrationTestFilterer: GatewayIntegrationTestFilterer{contract: contract}}, nil + return address, tx, &GatewayEVMZEVMTest{GatewayEVMZEVMTestCaller: GatewayEVMZEVMTestCaller{contract: contract}, GatewayEVMZEVMTestTransactor: GatewayEVMZEVMTestTransactor{contract: contract}, GatewayEVMZEVMTestFilterer: GatewayEVMZEVMTestFilterer{contract: contract}}, nil } -// GatewayIntegrationTest is an auto generated Go binding around an Ethereum contract. -type GatewayIntegrationTest struct { - GatewayIntegrationTestCaller // Read-only binding to the contract - GatewayIntegrationTestTransactor // Write-only binding to the contract - GatewayIntegrationTestFilterer // Log filterer for contract events +// GatewayEVMZEVMTest is an auto generated Go binding around an Ethereum contract. +type GatewayEVMZEVMTest struct { + GatewayEVMZEVMTestCaller // Read-only binding to the contract + GatewayEVMZEVMTestTransactor // Write-only binding to the contract + GatewayEVMZEVMTestFilterer // Log filterer for contract events } -// GatewayIntegrationTestCaller is an auto generated read-only Go binding around an Ethereum contract. -type GatewayIntegrationTestCaller struct { +// GatewayEVMZEVMTestCaller is an auto generated read-only Go binding around an Ethereum contract. +type GatewayEVMZEVMTestCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// GatewayIntegrationTestTransactor is an auto generated write-only Go binding around an Ethereum contract. -type GatewayIntegrationTestTransactor struct { +// GatewayEVMZEVMTestTransactor is an auto generated write-only Go binding around an Ethereum contract. +type GatewayEVMZEVMTestTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// GatewayIntegrationTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type GatewayIntegrationTestFilterer struct { +// GatewayEVMZEVMTestFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type GatewayEVMZEVMTestFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// GatewayIntegrationTestSession is an auto generated Go binding around an Ethereum contract, +// GatewayEVMZEVMTestSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type GatewayIntegrationTestSession struct { - Contract *GatewayIntegrationTest // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type GatewayEVMZEVMTestSession struct { + Contract *GatewayEVMZEVMTest // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// GatewayIntegrationTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// GatewayEVMZEVMTestCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type GatewayIntegrationTestCallerSession struct { - Contract *GatewayIntegrationTestCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type GatewayEVMZEVMTestCallerSession struct { + Contract *GatewayEVMZEVMTestCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// GatewayIntegrationTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// GatewayEVMZEVMTestTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type GatewayIntegrationTestTransactorSession struct { - Contract *GatewayIntegrationTestTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type GatewayEVMZEVMTestTransactorSession struct { + Contract *GatewayEVMZEVMTestTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// GatewayIntegrationTestRaw is an auto generated low-level Go binding around an Ethereum contract. -type GatewayIntegrationTestRaw struct { - Contract *GatewayIntegrationTest // Generic contract binding to access the raw methods on +// GatewayEVMZEVMTestRaw is an auto generated low-level Go binding around an Ethereum contract. +type GatewayEVMZEVMTestRaw struct { + Contract *GatewayEVMZEVMTest // Generic contract binding to access the raw methods on } -// GatewayIntegrationTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type GatewayIntegrationTestCallerRaw struct { - Contract *GatewayIntegrationTestCaller // Generic read-only contract binding to access the raw methods on +// GatewayEVMZEVMTestCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type GatewayEVMZEVMTestCallerRaw struct { + Contract *GatewayEVMZEVMTestCaller // Generic read-only contract binding to access the raw methods on } -// GatewayIntegrationTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type GatewayIntegrationTestTransactorRaw struct { - Contract *GatewayIntegrationTestTransactor // Generic write-only contract binding to access the raw methods on +// GatewayEVMZEVMTestTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type GatewayEVMZEVMTestTransactorRaw struct { + Contract *GatewayEVMZEVMTestTransactor // Generic write-only contract binding to access the raw methods on } -// NewGatewayIntegrationTest creates a new instance of GatewayIntegrationTest, bound to a specific deployed contract. -func NewGatewayIntegrationTest(address common.Address, backend bind.ContractBackend) (*GatewayIntegrationTest, error) { - contract, err := bindGatewayIntegrationTest(address, backend, backend, backend) +// NewGatewayEVMZEVMTest creates a new instance of GatewayEVMZEVMTest, bound to a specific deployed contract. +func NewGatewayEVMZEVMTest(address common.Address, backend bind.ContractBackend) (*GatewayEVMZEVMTest, error) { + contract, err := bindGatewayEVMZEVMTest(address, backend, backend, backend) if err != nil { return nil, err } - return &GatewayIntegrationTest{GatewayIntegrationTestCaller: GatewayIntegrationTestCaller{contract: contract}, GatewayIntegrationTestTransactor: GatewayIntegrationTestTransactor{contract: contract}, GatewayIntegrationTestFilterer: GatewayIntegrationTestFilterer{contract: contract}}, nil + return &GatewayEVMZEVMTest{GatewayEVMZEVMTestCaller: GatewayEVMZEVMTestCaller{contract: contract}, GatewayEVMZEVMTestTransactor: GatewayEVMZEVMTestTransactor{contract: contract}, GatewayEVMZEVMTestFilterer: GatewayEVMZEVMTestFilterer{contract: contract}}, nil } -// NewGatewayIntegrationTestCaller creates a new read-only instance of GatewayIntegrationTest, bound to a specific deployed contract. -func NewGatewayIntegrationTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayIntegrationTestCaller, error) { - contract, err := bindGatewayIntegrationTest(address, caller, nil, nil) +// NewGatewayEVMZEVMTestCaller creates a new read-only instance of GatewayEVMZEVMTest, bound to a specific deployed contract. +func NewGatewayEVMZEVMTestCaller(address common.Address, caller bind.ContractCaller) (*GatewayEVMZEVMTestCaller, error) { + contract, err := bindGatewayEVMZEVMTest(address, caller, nil, nil) if err != nil { return nil, err } - return &GatewayIntegrationTestCaller{contract: contract}, nil + return &GatewayEVMZEVMTestCaller{contract: contract}, nil } -// NewGatewayIntegrationTestTransactor creates a new write-only instance of GatewayIntegrationTest, bound to a specific deployed contract. -func NewGatewayIntegrationTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayIntegrationTestTransactor, error) { - contract, err := bindGatewayIntegrationTest(address, nil, transactor, nil) +// NewGatewayEVMZEVMTestTransactor creates a new write-only instance of GatewayEVMZEVMTest, bound to a specific deployed contract. +func NewGatewayEVMZEVMTestTransactor(address common.Address, transactor bind.ContractTransactor) (*GatewayEVMZEVMTestTransactor, error) { + contract, err := bindGatewayEVMZEVMTest(address, nil, transactor, nil) if err != nil { return nil, err } - return &GatewayIntegrationTestTransactor{contract: contract}, nil + return &GatewayEVMZEVMTestTransactor{contract: contract}, nil } -// NewGatewayIntegrationTestFilterer creates a new log filterer instance of GatewayIntegrationTest, bound to a specific deployed contract. -func NewGatewayIntegrationTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayIntegrationTestFilterer, error) { - contract, err := bindGatewayIntegrationTest(address, nil, nil, filterer) +// NewGatewayEVMZEVMTestFilterer creates a new log filterer instance of GatewayEVMZEVMTest, bound to a specific deployed contract. +func NewGatewayEVMZEVMTestFilterer(address common.Address, filterer bind.ContractFilterer) (*GatewayEVMZEVMTestFilterer, error) { + contract, err := bindGatewayEVMZEVMTest(address, nil, nil, filterer) if err != nil { return nil, err } - return &GatewayIntegrationTestFilterer{contract: contract}, nil + return &GatewayEVMZEVMTestFilterer{contract: contract}, nil } -// bindGatewayIntegrationTest binds a generic wrapper to an already deployed contract. -func bindGatewayIntegrationTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := GatewayIntegrationTestMetaData.GetAbi() +// bindGatewayEVMZEVMTest binds a generic wrapper to an already deployed contract. +func bindGatewayEVMZEVMTest(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := GatewayEVMZEVMTestMetaData.GetAbi() if err != nil { return nil, err } @@ -186,46 +186,46 @@ func bindGatewayIntegrationTest(address common.Address, caller bind.ContractCall // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayIntegrationTest.Contract.GatewayIntegrationTestCaller.contract.Call(opts, result, method, params...) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMZEVMTest.Contract.GatewayEVMZEVMTestCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.GatewayIntegrationTestTransactor.contract.Transfer(opts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.GatewayEVMZEVMTestTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_GatewayIntegrationTest *GatewayIntegrationTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.GatewayIntegrationTestTransactor.contract.Transact(opts, method, params...) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.GatewayEVMZEVMTestTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _GatewayIntegrationTest.Contract.contract.Call(opts, result, method, params...) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _GatewayEVMZEVMTest.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.contract.Transfer(opts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.contract.Transact(opts, method, params...) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.contract.Transact(opts, method, params...) } // ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. // // Solidity: function IS_TEST() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) ISTEST(opts *bind.CallOpts) (bool, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "IS_TEST") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "IS_TEST") if err != nil { return *new(bool), err @@ -240,23 +240,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ISTEST(opts *bind.C // ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. // // Solidity: function IS_TEST() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ISTEST() (bool, error) { - return _GatewayIntegrationTest.Contract.ISTEST(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) ISTEST() (bool, error) { + return _GatewayEVMZEVMTest.Contract.ISTEST(&_GatewayEVMZEVMTest.CallOpts) } // ISTEST is a free data retrieval call binding the contract method 0xfa7626d4. // // Solidity: function IS_TEST() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ISTEST() (bool, error) { - return _GatewayIntegrationTest.Contract.ISTEST(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) ISTEST() (bool, error) { + return _GatewayEVMZEVMTest.Contract.ISTEST(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. // // Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) ExcludeArtifacts(opts *bind.CallOpts) ([]string, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeArtifacts") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "excludeArtifacts") if err != nil { return *new([]string), err @@ -271,23 +271,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeArtifacts(op // ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. // // Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeArtifacts() ([]string, error) { - return _GatewayIntegrationTest.Contract.ExcludeArtifacts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) ExcludeArtifacts() ([]string, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeArtifacts(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeArtifacts is a free data retrieval call binding the contract method 0xb5508aa9. // // Solidity: function excludeArtifacts() view returns(string[] excludedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeArtifacts() ([]string, error) { - return _GatewayIntegrationTest.Contract.ExcludeArtifacts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) ExcludeArtifacts() ([]string, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeArtifacts(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. // // Solidity: function excludeContracts() view returns(address[] excludedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) ExcludeContracts(opts *bind.CallOpts) ([]common.Address, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeContracts") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "excludeContracts") if err != nil { return *new([]common.Address), err @@ -302,23 +302,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeContracts(op // ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. // // Solidity: function excludeContracts() view returns(address[] excludedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeContracts() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.ExcludeContracts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeContracts(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeContracts is a free data retrieval call binding the contract method 0xe20c9f71. // // Solidity: function excludeContracts() view returns(address[] excludedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeContracts() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.ExcludeContracts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) ExcludeContracts() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeContracts(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. // // Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) ExcludeSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeSelectors") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "excludeSelectors") if err != nil { return *new([]StdInvariantFuzzSelector), err @@ -333,23 +333,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSelectors(op // ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. // // Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { - return _GatewayIntegrationTest.Contract.ExcludeSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeSelectors(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeSelectors is a free data retrieval call binding the contract method 0xb0464fdc. // // Solidity: function excludeSelectors() view returns((address,bytes4[])[] excludedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { - return _GatewayIntegrationTest.Contract.ExcludeSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) ExcludeSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeSelectors(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. // // Solidity: function excludeSenders() view returns(address[] excludedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) ExcludeSenders(opts *bind.CallOpts) ([]common.Address, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "excludeSenders") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "excludeSenders") if err != nil { return *new([]common.Address), err @@ -364,23 +364,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) ExcludeSenders(opts // ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. // // Solidity: function excludeSenders() view returns(address[] excludedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) ExcludeSenders() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.ExcludeSenders(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeSenders(&_GatewayEVMZEVMTest.CallOpts) } // ExcludeSenders is a free data retrieval call binding the contract method 0x1ed7831c. // // Solidity: function excludeSenders() view returns(address[] excludedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) ExcludeSenders() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.ExcludeSenders(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) ExcludeSenders() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.ExcludeSenders(&_GatewayEVMZEVMTest.CallOpts) } // Failed is a free data retrieval call binding the contract method 0xba414fa6. // // Solidity: function failed() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) Failed(opts *bind.CallOpts) (bool, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) Failed(opts *bind.CallOpts) (bool, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "failed") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "failed") if err != nil { return *new(bool), err @@ -395,23 +395,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) Failed(opts *bind.C // Failed is a free data retrieval call binding the contract method 0xba414fa6. // // Solidity: function failed() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) Failed() (bool, error) { - return _GatewayIntegrationTest.Contract.Failed(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) Failed() (bool, error) { + return _GatewayEVMZEVMTest.Contract.Failed(&_GatewayEVMZEVMTest.CallOpts) } // Failed is a free data retrieval call binding the contract method 0xba414fa6. // // Solidity: function failed() view returns(bool) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) Failed() (bool, error) { - return _GatewayIntegrationTest.Contract.Failed(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) Failed() (bool, error) { + return _GatewayEVMZEVMTest.Contract.Failed(&_GatewayEVMZEVMTest.CallOpts) } // TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. // // Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetArtifactSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzArtifactSelector, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetArtifactSelectors") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetArtifactSelectors") if err != nil { return *new([]StdInvariantFuzzArtifactSelector), err @@ -426,23 +426,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifactSelec // TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. // // Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { - return _GatewayIntegrationTest.Contract.TargetArtifactSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayEVMZEVMTest.Contract.TargetArtifactSelectors(&_GatewayEVMZEVMTest.CallOpts) } // TargetArtifactSelectors is a free data retrieval call binding the contract method 0x66d9a9a0. // // Solidity: function targetArtifactSelectors() view returns((string,bytes4[])[] targetedArtifactSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { - return _GatewayIntegrationTest.Contract.TargetArtifactSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetArtifactSelectors() ([]StdInvariantFuzzArtifactSelector, error) { + return _GatewayEVMZEVMTest.Contract.TargetArtifactSelectors(&_GatewayEVMZEVMTest.CallOpts) } // TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. // // Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetArtifacts(opts *bind.CallOpts) ([]string, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetArtifacts") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetArtifacts") if err != nil { return *new([]string), err @@ -457,23 +457,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetArtifacts(opt // TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. // // Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetArtifacts() ([]string, error) { - return _GatewayIntegrationTest.Contract.TargetArtifacts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetArtifacts() ([]string, error) { + return _GatewayEVMZEVMTest.Contract.TargetArtifacts(&_GatewayEVMZEVMTest.CallOpts) } // TargetArtifacts is a free data retrieval call binding the contract method 0x85226c81. // // Solidity: function targetArtifacts() view returns(string[] targetedArtifacts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetArtifacts() ([]string, error) { - return _GatewayIntegrationTest.Contract.TargetArtifacts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetArtifacts() ([]string, error) { + return _GatewayEVMZEVMTest.Contract.TargetArtifacts(&_GatewayEVMZEVMTest.CallOpts) } // TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. // // Solidity: function targetContracts() view returns(address[] targetedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetContracts(opts *bind.CallOpts) ([]common.Address, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetContracts") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetContracts") if err != nil { return *new([]common.Address), err @@ -488,23 +488,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetContracts(opt // TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. // // Solidity: function targetContracts() view returns(address[] targetedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetContracts() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.TargetContracts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetContracts() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.TargetContracts(&_GatewayEVMZEVMTest.CallOpts) } // TargetContracts is a free data retrieval call binding the contract method 0x3f7286f4. // // Solidity: function targetContracts() view returns(address[] targetedContracts_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetContracts() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.TargetContracts(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetContracts() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.TargetContracts(&_GatewayEVMZEVMTest.CallOpts) } // TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. // // Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetInterfaces(opts *bind.CallOpts) ([]StdInvariantFuzzInterface, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetInterfaces") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetInterfaces") if err != nil { return *new([]StdInvariantFuzzInterface), err @@ -519,23 +519,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetInterfaces(op // TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. // // Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { - return _GatewayIntegrationTest.Contract.TargetInterfaces(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayEVMZEVMTest.Contract.TargetInterfaces(&_GatewayEVMZEVMTest.CallOpts) } // TargetInterfaces is a free data retrieval call binding the contract method 0x2ade3880. // // Solidity: function targetInterfaces() view returns((address,string[])[] targetedInterfaces_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { - return _GatewayIntegrationTest.Contract.TargetInterfaces(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetInterfaces() ([]StdInvariantFuzzInterface, error) { + return _GatewayEVMZEVMTest.Contract.TargetInterfaces(&_GatewayEVMZEVMTest.CallOpts) } // TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. // // Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetSelectors(opts *bind.CallOpts) ([]StdInvariantFuzzSelector, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetSelectors") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetSelectors") if err != nil { return *new([]StdInvariantFuzzSelector), err @@ -550,23 +550,23 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSelectors(opt // TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. // // Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { - return _GatewayIntegrationTest.Contract.TargetSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMZEVMTest.Contract.TargetSelectors(&_GatewayEVMZEVMTest.CallOpts) } // TargetSelectors is a free data retrieval call binding the contract method 0x916a17c6. // // Solidity: function targetSelectors() view returns((address,bytes4[])[] targetedSelectors_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { - return _GatewayIntegrationTest.Contract.TargetSelectors(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetSelectors() ([]StdInvariantFuzzSelector, error) { + return _GatewayEVMZEVMTest.Contract.TargetSelectors(&_GatewayEVMZEVMTest.CallOpts) } // TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. // // Solidity: function targetSenders() view returns(address[] targetedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCaller) TargetSenders(opts *bind.CallOpts) ([]common.Address, error) { var out []interface{} - err := _GatewayIntegrationTest.contract.Call(opts, &out, "targetSenders") + err := _GatewayEVMZEVMTest.contract.Call(opts, &out, "targetSenders") if err != nil { return *new([]common.Address), err @@ -581,62 +581,62 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestCaller) TargetSenders(opts // TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. // // Solidity: function targetSenders() view returns(address[] targetedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TargetSenders() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.TargetSenders(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TargetSenders() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.TargetSenders(&_GatewayEVMZEVMTest.CallOpts) } // TargetSenders is a free data retrieval call binding the contract method 0x3e5e3c23. // // Solidity: function targetSenders() view returns(address[] targetedSenders_) -func (_GatewayIntegrationTest *GatewayIntegrationTestCallerSession) TargetSenders() ([]common.Address, error) { - return _GatewayIntegrationTest.Contract.TargetSenders(&_GatewayIntegrationTest.CallOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestCallerSession) TargetSenders() ([]common.Address, error) { + return _GatewayEVMZEVMTest.Contract.TargetSenders(&_GatewayEVMZEVMTest.CallOpts) } // SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. // // Solidity: function setUp() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayIntegrationTest.contract.Transact(opts, "setUp") +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactor) SetUp(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.contract.Transact(opts, "setUp") } // SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. // // Solidity: function setUp() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) SetUp() (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.SetUp(&_GatewayIntegrationTest.TransactOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) SetUp() (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.SetUp(&_GatewayEVMZEVMTest.TransactOpts) } // SetUp is a paid mutator transaction binding the contract method 0x0a9254e4. // // Solidity: function setUp() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorSession) SetUp() (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.SetUp(&_GatewayIntegrationTest.TransactOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactorSession) SetUp() (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.SetUp(&_GatewayEVMZEVMTest.TransactOpts) } // TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. // // Solidity: function testCallReceiverEVMFromZEVM() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactor) TestCallReceiverEVMFromZEVM(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayIntegrationTest.contract.Transact(opts, "testCallReceiverEVMFromZEVM") +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactor) TestCallReceiverEVMFromZEVM(opts *bind.TransactOpts) (*types.Transaction, error) { + return _GatewayEVMZEVMTest.contract.Transact(opts, "testCallReceiverEVMFromZEVM") } // TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. // // Solidity: function testCallReceiverEVMFromZEVM() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayIntegrationTest.TransactOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayEVMZEVMTest.TransactOpts) } // TestCallReceiverEVMFromZEVM is a paid mutator transaction binding the contract method 0x9683c695. // // Solidity: function testCallReceiverEVMFromZEVM() returns() -func (_GatewayIntegrationTest *GatewayIntegrationTestTransactorSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { - return _GatewayIntegrationTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayIntegrationTest.TransactOpts) +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestTransactorSession) TestCallReceiverEVMFromZEVM() (*types.Transaction, error) { + return _GatewayEVMZEVMTest.Contract.TestCallReceiverEVMFromZEVM(&_GatewayEVMZEVMTest.TransactOpts) } -// GatewayIntegrationTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestCallIterator struct { - Event *GatewayIntegrationTestCall // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestCallIterator struct { + Event *GatewayEVMZEVMTestCall // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -650,7 +650,7 @@ type GatewayIntegrationTestCallIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestCallIterator) Next() bool { +func (it *GatewayEVMZEVMTestCallIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -659,7 +659,7 @@ func (it *GatewayIntegrationTestCallIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestCall) + it.Event = new(GatewayEVMZEVMTestCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -674,7 +674,7 @@ func (it *GatewayIntegrationTestCallIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestCall) + it.Event = new(GatewayEVMZEVMTestCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -690,19 +690,19 @@ func (it *GatewayIntegrationTestCallIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestCallIterator) Error() error { +func (it *GatewayEVMZEVMTestCallIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestCallIterator) Close() error { +func (it *GatewayEVMZEVMTestCallIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestCall represents a Call event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestCall struct { +// GatewayEVMZEVMTestCall represents a Call event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestCall struct { Sender common.Address Receiver []byte Message []byte @@ -712,31 +712,31 @@ type GatewayIntegrationTestCall struct { // FilterCall is a free log retrieval operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // // Solidity: event Call(address indexed sender, bytes receiver, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address) (*GatewayIntegrationTestCallIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address) (*GatewayEVMZEVMTestCallIterator, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Call", senderRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "Call", senderRule) if err != nil { return nil, err } - return &GatewayIntegrationTestCallIterator{contract: _GatewayIntegrationTest.contract, event: "Call", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestCallIterator{contract: _GatewayEVMZEVMTest.contract, event: "Call", logs: logs, sub: sub}, nil } // WatchCall is a free log subscription operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // // Solidity: event Call(address indexed sender, bytes receiver, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestCall, sender []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestCall, sender []common.Address) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { senderRule = append(senderRule, senderItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Call", senderRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "Call", senderRule) if err != nil { return nil, err } @@ -746,8 +746,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall(opts *b select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestCall) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call", log); err != nil { + event := new(GatewayEVMZEVMTestCall) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Call", log); err != nil { return err } event.Raw = log @@ -771,18 +771,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall(opts *b // ParseCall is a log parse operation binding the contract event 0x2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f. // // Solidity: event Call(address indexed sender, bytes receiver, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseCall(log types.Log) (*GatewayIntegrationTestCall, error) { - event := new(GatewayIntegrationTestCall) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseCall(log types.Log) (*GatewayEVMZEVMTestCall, error) { + event := new(GatewayEVMZEVMTestCall) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Call", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestCall0Iterator is returned from FilterCall0 and is used to iterate over the raw logs and unpacked data for Call0 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestCall0Iterator struct { - Event *GatewayIntegrationTestCall0 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestCall0Iterator is returned from FilterCall0 and is used to iterate over the raw logs and unpacked data for Call0 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestCall0Iterator struct { + Event *GatewayEVMZEVMTestCall0 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -796,7 +796,7 @@ type GatewayIntegrationTestCall0Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestCall0Iterator) Next() bool { +func (it *GatewayEVMZEVMTestCall0Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -805,7 +805,7 @@ func (it *GatewayIntegrationTestCall0Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestCall0) + it.Event = new(GatewayEVMZEVMTestCall0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -820,7 +820,7 @@ func (it *GatewayIntegrationTestCall0Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestCall0) + it.Event = new(GatewayEVMZEVMTestCall0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -836,19 +836,19 @@ func (it *GatewayIntegrationTestCall0Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestCall0Iterator) Error() error { +func (it *GatewayEVMZEVMTestCall0Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestCall0Iterator) Close() error { +func (it *GatewayEVMZEVMTestCall0Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestCall0 represents a Call0 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestCall0 struct { +// GatewayEVMZEVMTestCall0 represents a Call0 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestCall0 struct { Sender common.Address Receiver common.Address Payload []byte @@ -858,7 +858,7 @@ type GatewayIntegrationTestCall0 struct { // FilterCall0 is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // // Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterCall0(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayIntegrationTestCall0Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterCall0(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMZEVMTestCall0Iterator, error) { var senderRule []interface{} for _, senderItem := range sender { @@ -869,17 +869,17 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterCall0(opts receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Call0", senderRule, receiverRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "Call0", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayIntegrationTestCall0Iterator{contract: _GatewayIntegrationTest.contract, event: "Call0", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestCall0Iterator{contract: _GatewayEVMZEVMTest.contract, event: "Call0", logs: logs, sub: sub}, nil } // WatchCall0 is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // // Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestCall0, sender []common.Address, receiver []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchCall0(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestCall0, sender []common.Address, receiver []common.Address) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { @@ -890,7 +890,7 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall0(opts * receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Call0", senderRule, receiverRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "Call0", senderRule, receiverRule) if err != nil { return nil, err } @@ -900,8 +900,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall0(opts * select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestCall0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call0", log); err != nil { + event := new(GatewayEVMZEVMTestCall0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Call0", log); err != nil { return err } event.Raw = log @@ -925,18 +925,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchCall0(opts * // ParseCall0 is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // // Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseCall0(log types.Log) (*GatewayIntegrationTestCall0, error) { - event := new(GatewayIntegrationTestCall0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Call0", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseCall0(log types.Log) (*GatewayEVMZEVMTestCall0, error) { + event := new(GatewayEVMZEVMTestCall0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Call0", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestDepositIterator struct { - Event *GatewayIntegrationTestDeposit // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestDepositIterator struct { + Event *GatewayEVMZEVMTestDeposit // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -950,7 +950,7 @@ type GatewayIntegrationTestDepositIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestDepositIterator) Next() bool { +func (it *GatewayEVMZEVMTestDepositIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -959,7 +959,7 @@ func (it *GatewayIntegrationTestDepositIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestDeposit) + it.Event = new(GatewayEVMZEVMTestDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -974,7 +974,7 @@ func (it *GatewayIntegrationTestDepositIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestDeposit) + it.Event = new(GatewayEVMZEVMTestDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -990,19 +990,19 @@ func (it *GatewayIntegrationTestDepositIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestDepositIterator) Error() error { +func (it *GatewayEVMZEVMTestDepositIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestDepositIterator) Close() error { +func (it *GatewayEVMZEVMTestDepositIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestDeposit represents a Deposit event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestDeposit struct { +// GatewayEVMZEVMTestDeposit represents a Deposit event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestDeposit struct { Sender common.Address Receiver common.Address Amount *big.Int @@ -1014,7 +1014,7 @@ type GatewayIntegrationTestDeposit struct { // FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // // Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayIntegrationTestDepositIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMZEVMTestDepositIterator, error) { var senderRule []interface{} for _, senderItem := range sender { @@ -1025,17 +1025,17 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterDeposit(opt receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayIntegrationTestDepositIterator{contract: _GatewayIntegrationTest.contract, event: "Deposit", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestDepositIterator{contract: _GatewayEVMZEVMTest.contract, event: "Deposit", logs: logs, sub: sub}, nil } // WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // // Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { var senderRule []interface{} for _, senderItem := range sender { @@ -1046,7 +1046,7 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchDeposit(opts receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } @@ -1056,8 +1056,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchDeposit(opts select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestDeposit) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Deposit", log); err != nil { + event := new(GatewayEVMZEVMTestDeposit) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Deposit", log); err != nil { return err } event.Raw = log @@ -1081,18 +1081,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchDeposit(opts // ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // // Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseDeposit(log types.Log) (*GatewayIntegrationTestDeposit, error) { - event := new(GatewayIntegrationTestDeposit) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Deposit", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseDeposit(log types.Log) (*GatewayEVMZEVMTestDeposit, error) { + event := new(GatewayEVMZEVMTestDeposit) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Deposit", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestExecutedIterator struct { - Event *GatewayIntegrationTestExecuted // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestExecutedIterator struct { + Event *GatewayEVMZEVMTestExecuted // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1106,7 +1106,7 @@ type GatewayIntegrationTestExecutedIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestExecutedIterator) Next() bool { +func (it *GatewayEVMZEVMTestExecutedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1115,7 +1115,7 @@ func (it *GatewayIntegrationTestExecutedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestExecuted) + it.Event = new(GatewayEVMZEVMTestExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1130,7 +1130,7 @@ func (it *GatewayIntegrationTestExecutedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestExecuted) + it.Event = new(GatewayEVMZEVMTestExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1146,19 +1146,19 @@ func (it *GatewayIntegrationTestExecutedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestExecutedIterator) Error() error { +func (it *GatewayEVMZEVMTestExecutedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestExecutedIterator) Close() error { +func (it *GatewayEVMZEVMTestExecutedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestExecuted represents a Executed event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestExecuted struct { +// GatewayEVMZEVMTestExecuted represents a Executed event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestExecuted struct { Destination common.Address Value *big.Int Data []byte @@ -1168,31 +1168,31 @@ type GatewayIntegrationTestExecuted struct { // FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // // Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayIntegrationTestExecutedIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMZEVMTestExecutedIterator, error) { var destinationRule []interface{} for _, destinationItem := range destination { destinationRule = append(destinationRule, destinationItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Executed", destinationRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "Executed", destinationRule) if err != nil { return nil, err } - return &GatewayIntegrationTestExecutedIterator{contract: _GatewayIntegrationTest.contract, event: "Executed", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestExecutedIterator{contract: _GatewayEVMZEVMTest.contract, event: "Executed", logs: logs, sub: sub}, nil } // WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // // Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestExecuted, destination []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestExecuted, destination []common.Address) (event.Subscription, error) { var destinationRule []interface{} for _, destinationItem := range destination { destinationRule = append(destinationRule, destinationItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Executed", destinationRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "Executed", destinationRule) if err != nil { return nil, err } @@ -1202,8 +1202,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecuted(opt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestExecuted) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Executed", log); err != nil { + event := new(GatewayEVMZEVMTestExecuted) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Executed", log); err != nil { return err } event.Raw = log @@ -1227,18 +1227,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecuted(opt // ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // // Solidity: event Executed(address indexed destination, uint256 value, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseExecuted(log types.Log) (*GatewayIntegrationTestExecuted, error) { - event := new(GatewayIntegrationTestExecuted) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Executed", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseExecuted(log types.Log) (*GatewayEVMZEVMTestExecuted, error) { + event := new(GatewayEVMZEVMTestExecuted) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Executed", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestExecutedWithERC20Iterator struct { - Event *GatewayIntegrationTestExecutedWithERC20 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestExecutedWithERC20Iterator struct { + Event *GatewayEVMZEVMTestExecutedWithERC20 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1252,7 +1252,7 @@ type GatewayIntegrationTestExecutedWithERC20Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Next() bool { +func (it *GatewayEVMZEVMTestExecutedWithERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1261,7 +1261,7 @@ func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestExecutedWithERC20) + it.Event = new(GatewayEVMZEVMTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1276,7 +1276,7 @@ func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestExecutedWithERC20) + it.Event = new(GatewayEVMZEVMTestExecutedWithERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1292,19 +1292,19 @@ func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Error() error { +func (it *GatewayEVMZEVMTestExecutedWithERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestExecutedWithERC20Iterator) Close() error { +func (it *GatewayEVMZEVMTestExecutedWithERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestExecutedWithERC20 struct { +// GatewayEVMZEVMTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestExecutedWithERC20 struct { Token common.Address To common.Address Amount *big.Int @@ -1315,7 +1315,7 @@ type GatewayIntegrationTestExecutedWithERC20 struct { // FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // // Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayIntegrationTestExecutedWithERC20Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMZEVMTestExecutedWithERC20Iterator, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -1326,17 +1326,17 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterExecutedWit toRule = append(toRule, toItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } - return &GatewayIntegrationTestExecutedWithERC20Iterator{contract: _GatewayIntegrationTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestExecutedWithERC20Iterator{contract: _GatewayEVMZEVMTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil } // WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // // Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { var tokenRule []interface{} for _, tokenItem := range token { @@ -1347,7 +1347,7 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecutedWith toRule = append(toRule, toItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -1357,8 +1357,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecutedWith select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestExecutedWithERC20) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + event := new(GatewayEVMZEVMTestExecutedWithERC20) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -1382,18 +1382,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchExecutedWith // ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // // Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayIntegrationTestExecutedWithERC20, error) { - event := new(GatewayIntegrationTestExecutedWithERC20) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMZEVMTestExecutedWithERC20, error) { + event := new(GatewayEVMZEVMTestExecutedWithERC20) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedERC20Iterator struct { - Event *GatewayIntegrationTestReceivedERC20 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestReceivedERC20Iterator is returned from FilterReceivedERC20 and is used to iterate over the raw logs and unpacked data for ReceivedERC20 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedERC20Iterator struct { + Event *GatewayEVMZEVMTestReceivedERC20 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1407,7 +1407,7 @@ type GatewayIntegrationTestReceivedERC20Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestReceivedERC20Iterator) Next() bool { +func (it *GatewayEVMZEVMTestReceivedERC20Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1416,7 +1416,7 @@ func (it *GatewayIntegrationTestReceivedERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedERC20) + it.Event = new(GatewayEVMZEVMTestReceivedERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1431,7 +1431,7 @@ func (it *GatewayIntegrationTestReceivedERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedERC20) + it.Event = new(GatewayEVMZEVMTestReceivedERC20) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1447,19 +1447,19 @@ func (it *GatewayIntegrationTestReceivedERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestReceivedERC20Iterator) Error() error { +func (it *GatewayEVMZEVMTestReceivedERC20Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestReceivedERC20Iterator) Close() error { +func (it *GatewayEVMZEVMTestReceivedERC20Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestReceivedERC20 represents a ReceivedERC20 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedERC20 struct { +// GatewayEVMZEVMTestReceivedERC20 represents a ReceivedERC20 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedERC20 struct { Sender common.Address Amount *big.Int Token common.Address @@ -1470,21 +1470,21 @@ type GatewayIntegrationTestReceivedERC20 struct { // FilterReceivedERC20 is a free log retrieval operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // // Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedERC20Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterReceivedERC20(opts *bind.FilterOpts) (*GatewayEVMZEVMTestReceivedERC20Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedERC20") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "ReceivedERC20") if err != nil { return nil, err } - return &GatewayIntegrationTestReceivedERC20Iterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestReceivedERC20Iterator{contract: _GatewayEVMZEVMTest.contract, event: "ReceivedERC20", logs: logs, sub: sub}, nil } // WatchReceivedERC20 is a free log subscription operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // // Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedERC20) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchReceivedERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestReceivedERC20) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedERC20") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "ReceivedERC20") if err != nil { return nil, err } @@ -1494,8 +1494,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedERC2 select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestReceivedERC20) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { + event := new(GatewayEVMZEVMTestReceivedERC20) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { return err } event.Raw = log @@ -1519,18 +1519,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedERC2 // ParseReceivedERC20 is a log parse operation binding the contract event 0x2b58128f24a9f59127cc5b5430d70542b22220f2d9adaa86e442b816ab98af60. // // Solidity: event ReceivedERC20(address sender, uint256 amount, address token, address destination) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedERC20(log types.Log) (*GatewayIntegrationTestReceivedERC20, error) { - event := new(GatewayIntegrationTestReceivedERC20) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseReceivedERC20(log types.Log) (*GatewayEVMZEVMTestReceivedERC20, error) { + event := new(GatewayEVMZEVMTestReceivedERC20) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedERC20", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedNoParamsIterator struct { - Event *GatewayIntegrationTestReceivedNoParams // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestReceivedNoParamsIterator is returned from FilterReceivedNoParams and is used to iterate over the raw logs and unpacked data for ReceivedNoParams events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedNoParamsIterator struct { + Event *GatewayEVMZEVMTestReceivedNoParams // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1544,7 +1544,7 @@ type GatewayIntegrationTestReceivedNoParamsIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestReceivedNoParamsIterator) Next() bool { +func (it *GatewayEVMZEVMTestReceivedNoParamsIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1553,7 +1553,7 @@ func (it *GatewayIntegrationTestReceivedNoParamsIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedNoParams) + it.Event = new(GatewayEVMZEVMTestReceivedNoParams) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1568,7 +1568,7 @@ func (it *GatewayIntegrationTestReceivedNoParamsIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedNoParams) + it.Event = new(GatewayEVMZEVMTestReceivedNoParams) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1584,19 +1584,19 @@ func (it *GatewayIntegrationTestReceivedNoParamsIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestReceivedNoParamsIterator) Error() error { +func (it *GatewayEVMZEVMTestReceivedNoParamsIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestReceivedNoParamsIterator) Close() error { +func (it *GatewayEVMZEVMTestReceivedNoParamsIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestReceivedNoParams represents a ReceivedNoParams event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedNoParams struct { +// GatewayEVMZEVMTestReceivedNoParams represents a ReceivedNoParams event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedNoParams struct { Sender common.Address Raw types.Log // Blockchain specific contextual infos } @@ -1604,21 +1604,21 @@ type GatewayIntegrationTestReceivedNoParams struct { // FilterReceivedNoParams is a free log retrieval operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // // Solidity: event ReceivedNoParams(address sender) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedNoParamsIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterReceivedNoParams(opts *bind.FilterOpts) (*GatewayEVMZEVMTestReceivedNoParamsIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedNoParams") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "ReceivedNoParams") if err != nil { return nil, err } - return &GatewayIntegrationTestReceivedNoParamsIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestReceivedNoParamsIterator{contract: _GatewayEVMZEVMTest.contract, event: "ReceivedNoParams", logs: logs, sub: sub}, nil } // WatchReceivedNoParams is a free log subscription operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // // Solidity: event ReceivedNoParams(address sender) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedNoParams) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchReceivedNoParams(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestReceivedNoParams) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedNoParams") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "ReceivedNoParams") if err != nil { return nil, err } @@ -1628,8 +1628,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNoPa select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestReceivedNoParams) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { + event := new(GatewayEVMZEVMTestReceivedNoParams) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { return err } event.Raw = log @@ -1653,18 +1653,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNoPa // ParseReceivedNoParams is a log parse operation binding the contract event 0xbcaadb46b82a48af60b608f58959ae6b8310d1b0a0d094c2e9ec3208ed39f2a0. // // Solidity: event ReceivedNoParams(address sender) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedNoParams(log types.Log) (*GatewayIntegrationTestReceivedNoParams, error) { - event := new(GatewayIntegrationTestReceivedNoParams) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseReceivedNoParams(log types.Log) (*GatewayEVMZEVMTestReceivedNoParams, error) { + event := new(GatewayEVMZEVMTestReceivedNoParams) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedNoParams", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedNonPayableIterator struct { - Event *GatewayIntegrationTestReceivedNonPayable // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestReceivedNonPayableIterator is returned from FilterReceivedNonPayable and is used to iterate over the raw logs and unpacked data for ReceivedNonPayable events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedNonPayableIterator struct { + Event *GatewayEVMZEVMTestReceivedNonPayable // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1678,7 +1678,7 @@ type GatewayIntegrationTestReceivedNonPayableIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestReceivedNonPayableIterator) Next() bool { +func (it *GatewayEVMZEVMTestReceivedNonPayableIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1687,7 +1687,7 @@ func (it *GatewayIntegrationTestReceivedNonPayableIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedNonPayable) + it.Event = new(GatewayEVMZEVMTestReceivedNonPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1702,7 +1702,7 @@ func (it *GatewayIntegrationTestReceivedNonPayableIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedNonPayable) + it.Event = new(GatewayEVMZEVMTestReceivedNonPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1718,19 +1718,19 @@ func (it *GatewayIntegrationTestReceivedNonPayableIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestReceivedNonPayableIterator) Error() error { +func (it *GatewayEVMZEVMTestReceivedNonPayableIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestReceivedNonPayableIterator) Close() error { +func (it *GatewayEVMZEVMTestReceivedNonPayableIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestReceivedNonPayable represents a ReceivedNonPayable event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedNonPayable struct { +// GatewayEVMZEVMTestReceivedNonPayable represents a ReceivedNonPayable event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedNonPayable struct { Sender common.Address Strs []string Nums []*big.Int @@ -1741,21 +1741,21 @@ type GatewayIntegrationTestReceivedNonPayable struct { // FilterReceivedNonPayable is a free log retrieval operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // // Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedNonPayableIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterReceivedNonPayable(opts *bind.FilterOpts) (*GatewayEVMZEVMTestReceivedNonPayableIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedNonPayable") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "ReceivedNonPayable") if err != nil { return nil, err } - return &GatewayIntegrationTestReceivedNonPayableIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestReceivedNonPayableIterator{contract: _GatewayEVMZEVMTest.contract, event: "ReceivedNonPayable", logs: logs, sub: sub}, nil } // WatchReceivedNonPayable is a free log subscription operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // // Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedNonPayable) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchReceivedNonPayable(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestReceivedNonPayable) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedNonPayable") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "ReceivedNonPayable") if err != nil { return nil, err } @@ -1765,8 +1765,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNonP select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestReceivedNonPayable) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { + event := new(GatewayEVMZEVMTestReceivedNonPayable) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { return err } event.Raw = log @@ -1790,18 +1790,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedNonP // ParseReceivedNonPayable is a log parse operation binding the contract event 0x74a53cd528a921fca7dbdee62f86819051d3cc98f214951f4238e8843f20b146. // // Solidity: event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedNonPayable(log types.Log) (*GatewayIntegrationTestReceivedNonPayable, error) { - event := new(GatewayIntegrationTestReceivedNonPayable) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseReceivedNonPayable(log types.Log) (*GatewayEVMZEVMTestReceivedNonPayable, error) { + event := new(GatewayEVMZEVMTestReceivedNonPayable) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedNonPayable", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedPayableIterator struct { - Event *GatewayIntegrationTestReceivedPayable // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestReceivedPayableIterator is returned from FilterReceivedPayable and is used to iterate over the raw logs and unpacked data for ReceivedPayable events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedPayableIterator struct { + Event *GatewayEVMZEVMTestReceivedPayable // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1815,7 +1815,7 @@ type GatewayIntegrationTestReceivedPayableIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestReceivedPayableIterator) Next() bool { +func (it *GatewayEVMZEVMTestReceivedPayableIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1824,7 +1824,7 @@ func (it *GatewayIntegrationTestReceivedPayableIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedPayable) + it.Event = new(GatewayEVMZEVMTestReceivedPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1839,7 +1839,7 @@ func (it *GatewayIntegrationTestReceivedPayableIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestReceivedPayable) + it.Event = new(GatewayEVMZEVMTestReceivedPayable) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1855,19 +1855,19 @@ func (it *GatewayIntegrationTestReceivedPayableIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestReceivedPayableIterator) Error() error { +func (it *GatewayEVMZEVMTestReceivedPayableIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestReceivedPayableIterator) Close() error { +func (it *GatewayEVMZEVMTestReceivedPayableIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestReceivedPayable represents a ReceivedPayable event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestReceivedPayable struct { +// GatewayEVMZEVMTestReceivedPayable represents a ReceivedPayable event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestReceivedPayable struct { Sender common.Address Value *big.Int Str string @@ -1879,21 +1879,21 @@ type GatewayIntegrationTestReceivedPayable struct { // FilterReceivedPayable is a free log retrieval operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // // Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*GatewayIntegrationTestReceivedPayableIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterReceivedPayable(opts *bind.FilterOpts) (*GatewayEVMZEVMTestReceivedPayableIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "ReceivedPayable") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "ReceivedPayable") if err != nil { return nil, err } - return &GatewayIntegrationTestReceivedPayableIterator{contract: _GatewayIntegrationTest.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestReceivedPayableIterator{contract: _GatewayEVMZEVMTest.contract, event: "ReceivedPayable", logs: logs, sub: sub}, nil } // WatchReceivedPayable is a free log subscription operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // // Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestReceivedPayable) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchReceivedPayable(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestReceivedPayable) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "ReceivedPayable") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "ReceivedPayable") if err != nil { return nil, err } @@ -1903,8 +1903,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedPaya select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestReceivedPayable) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { + event := new(GatewayEVMZEVMTestReceivedPayable) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { return err } event.Raw = log @@ -1928,18 +1928,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchReceivedPaya // ParseReceivedPayable is a log parse operation binding the contract event 0x1f1ff1f5fb41346850b2f5c04e6c767e2f1c8a525c5c0c5cdb60cdf3ca5f62fa. // // Solidity: event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseReceivedPayable(log types.Log) (*GatewayIntegrationTestReceivedPayable, error) { - event := new(GatewayIntegrationTestReceivedPayable) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseReceivedPayable(log types.Log) (*GatewayEVMZEVMTestReceivedPayable, error) { + event := new(GatewayEVMZEVMTestReceivedPayable) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "ReceivedPayable", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestWithdrawalIterator struct { - Event *GatewayIntegrationTestWithdrawal // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestWithdrawalIterator is returned from FilterWithdrawal and is used to iterate over the raw logs and unpacked data for Withdrawal events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestWithdrawalIterator struct { + Event *GatewayEVMZEVMTestWithdrawal // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1953,7 +1953,7 @@ type GatewayIntegrationTestWithdrawalIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestWithdrawalIterator) Next() bool { +func (it *GatewayEVMZEVMTestWithdrawalIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1962,7 +1962,7 @@ func (it *GatewayIntegrationTestWithdrawalIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestWithdrawal) + it.Event = new(GatewayEVMZEVMTestWithdrawal) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1977,7 +1977,7 @@ func (it *GatewayIntegrationTestWithdrawalIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestWithdrawal) + it.Event = new(GatewayEVMZEVMTestWithdrawal) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1993,19 +1993,19 @@ func (it *GatewayIntegrationTestWithdrawalIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestWithdrawalIterator) Error() error { +func (it *GatewayEVMZEVMTestWithdrawalIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestWithdrawalIterator) Close() error { +func (it *GatewayEVMZEVMTestWithdrawalIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestWithdrawal represents a Withdrawal event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestWithdrawal struct { +// GatewayEVMZEVMTestWithdrawal represents a Withdrawal event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestWithdrawal struct { From common.Address To []byte Value *big.Int @@ -2018,31 +2018,31 @@ type GatewayIntegrationTestWithdrawal struct { // FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. // // Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayIntegrationTestWithdrawalIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayEVMZEVMTestWithdrawalIterator, error) { var fromRule []interface{} for _, fromItem := range from { fromRule = append(fromRule, fromItem) } - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "Withdrawal", fromRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "Withdrawal", fromRule) if err != nil { return nil, err } - return &GatewayIntegrationTestWithdrawalIterator{contract: _GatewayIntegrationTest.contract, event: "Withdrawal", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestWithdrawalIterator{contract: _GatewayEVMZEVMTest.contract, event: "Withdrawal", logs: logs, sub: sub}, nil } // WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. // // Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestWithdrawal, from []common.Address) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestWithdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} for _, fromItem := range from { fromRule = append(fromRule, fromItem) } - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "Withdrawal", fromRule) + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "Withdrawal", fromRule) if err != nil { return nil, err } @@ -2052,8 +2052,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchWithdrawal(o select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestWithdrawal) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { + event := new(GatewayEVMZEVMTestWithdrawal) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { return err } event.Raw = log @@ -2077,18 +2077,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchWithdrawal(o // ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. // // Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseWithdrawal(log types.Log) (*GatewayIntegrationTestWithdrawal, error) { - event := new(GatewayIntegrationTestWithdrawal) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseWithdrawal(log types.Log) (*GatewayEVMZEVMTestWithdrawal, error) { + event := new(GatewayEVMZEVMTestWithdrawal) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogIterator struct { - Event *GatewayIntegrationTestLog // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogIterator struct { + Event *GatewayEVMZEVMTestLog // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2102,7 +2102,7 @@ type GatewayIntegrationTestLogIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2111,7 +2111,7 @@ func (it *GatewayIntegrationTestLogIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLog) + it.Event = new(GatewayEVMZEVMTestLog) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2126,7 +2126,7 @@ func (it *GatewayIntegrationTestLogIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLog) + it.Event = new(GatewayEVMZEVMTestLog) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2142,19 +2142,19 @@ func (it *GatewayIntegrationTestLogIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogIterator) Error() error { +func (it *GatewayEVMZEVMTestLogIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogIterator) Close() error { +func (it *GatewayEVMZEVMTestLogIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLog represents a Log event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLog struct { +// GatewayEVMZEVMTestLog represents a Log event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLog struct { Arg0 string Raw types.Log // Blockchain specific contextual infos } @@ -2162,21 +2162,21 @@ type GatewayIntegrationTestLog struct { // FilterLog is a free log retrieval operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. // // Solidity: event log(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLog(opts *bind.FilterOpts) (*GatewayIntegrationTestLogIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLog(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log") if err != nil { return nil, err } - return &GatewayIntegrationTestLogIterator{contract: _GatewayIntegrationTest.contract, event: "log", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogIterator{contract: _GatewayEVMZEVMTest.contract, event: "log", logs: logs, sub: sub}, nil } // WatchLog is a free log subscription operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. // // Solidity: event log(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLog) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLog) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log") if err != nil { return nil, err } @@ -2186,8 +2186,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLog(opts *bi select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLog) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log", log); err != nil { + event := new(GatewayEVMZEVMTestLog) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log", log); err != nil { return err } event.Raw = log @@ -2211,18 +2211,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLog(opts *bi // ParseLog is a log parse operation binding the contract event 0x41304facd9323d75b11bcdd609cb38effffdb05710f7caf0e9b16c6d9d709f50. // // Solidity: event log(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLog(log types.Log) (*GatewayIntegrationTestLog, error) { - event := new(GatewayIntegrationTestLog) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLog(log types.Log) (*GatewayEVMZEVMTestLog, error) { + event := new(GatewayEVMZEVMTestLog) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogAddressIterator struct { - Event *GatewayIntegrationTestLogAddress // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogAddressIterator is returned from FilterLogAddress and is used to iterate over the raw logs and unpacked data for LogAddress events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogAddressIterator struct { + Event *GatewayEVMZEVMTestLogAddress // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2236,7 +2236,7 @@ type GatewayIntegrationTestLogAddressIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogAddressIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogAddressIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2245,7 +2245,7 @@ func (it *GatewayIntegrationTestLogAddressIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogAddress) + it.Event = new(GatewayEVMZEVMTestLogAddress) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2260,7 +2260,7 @@ func (it *GatewayIntegrationTestLogAddressIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogAddress) + it.Event = new(GatewayEVMZEVMTestLogAddress) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2276,19 +2276,19 @@ func (it *GatewayIntegrationTestLogAddressIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogAddressIterator) Error() error { +func (it *GatewayEVMZEVMTestLogAddressIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogAddressIterator) Close() error { +func (it *GatewayEVMZEVMTestLogAddressIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogAddress represents a LogAddress event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogAddress struct { +// GatewayEVMZEVMTestLogAddress represents a LogAddress event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogAddress struct { Arg0 common.Address Raw types.Log // Blockchain specific contextual infos } @@ -2296,21 +2296,21 @@ type GatewayIntegrationTestLogAddress struct { // FilterLogAddress is a free log retrieval operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. // // Solidity: event log_address(address arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*GatewayIntegrationTestLogAddressIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogAddress(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogAddressIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_address") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_address") if err != nil { return nil, err } - return &GatewayIntegrationTestLogAddressIterator{contract: _GatewayIntegrationTest.contract, event: "log_address", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogAddressIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_address", logs: logs, sub: sub}, nil } // WatchLogAddress is a free log subscription operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. // // Solidity: event log_address(address arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogAddress) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogAddress(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogAddress) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_address") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_address") if err != nil { return nil, err } @@ -2320,8 +2320,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogAddress(o select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogAddress) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_address", log); err != nil { + event := new(GatewayEVMZEVMTestLogAddress) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_address", log); err != nil { return err } event.Raw = log @@ -2345,18 +2345,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogAddress(o // ParseLogAddress is a log parse operation binding the contract event 0x7ae74c527414ae135fd97047b12921a5ec3911b804197855d67e25c7b75ee6f3. // // Solidity: event log_address(address arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogAddress(log types.Log) (*GatewayIntegrationTestLogAddress, error) { - event := new(GatewayIntegrationTestLogAddress) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_address", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogAddress(log types.Log) (*GatewayEVMZEVMTestLogAddress, error) { + event := new(GatewayEVMZEVMTestLogAddress) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_address", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArrayIterator struct { - Event *GatewayIntegrationTestLogArray // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogArrayIterator is returned from FilterLogArray and is used to iterate over the raw logs and unpacked data for LogArray events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArrayIterator struct { + Event *GatewayEVMZEVMTestLogArray // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2370,7 +2370,7 @@ type GatewayIntegrationTestLogArrayIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogArrayIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogArrayIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2379,7 +2379,7 @@ func (it *GatewayIntegrationTestLogArrayIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray) + it.Event = new(GatewayEVMZEVMTestLogArray) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2394,7 +2394,7 @@ func (it *GatewayIntegrationTestLogArrayIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray) + it.Event = new(GatewayEVMZEVMTestLogArray) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2410,19 +2410,19 @@ func (it *GatewayIntegrationTestLogArrayIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogArrayIterator) Error() error { +func (it *GatewayEVMZEVMTestLogArrayIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogArrayIterator) Close() error { +func (it *GatewayEVMZEVMTestLogArrayIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogArray represents a LogArray event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArray struct { +// GatewayEVMZEVMTestLogArray represents a LogArray event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArray struct { Val []*big.Int Raw types.Log // Blockchain specific contextual infos } @@ -2430,21 +2430,21 @@ type GatewayIntegrationTestLogArray struct { // FilterLogArray is a free log retrieval operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. // // Solidity: event log_array(uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArrayIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogArray(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogArrayIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_array") if err != nil { return nil, err } - return &GatewayIntegrationTestLogArrayIterator{contract: _GatewayIntegrationTest.contract, event: "log_array", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogArrayIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_array", logs: logs, sub: sub}, nil } // WatchLogArray is a free log subscription operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. // // Solidity: event log_array(uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogArray(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogArray) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_array") if err != nil { return nil, err } @@ -2454,8 +2454,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray(opt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogArray) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array", log); err != nil { + event := new(GatewayEVMZEVMTestLogArray) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array", log); err != nil { return err } event.Raw = log @@ -2479,18 +2479,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray(opt // ParseLogArray is a log parse operation binding the contract event 0xfb102865d50addddf69da9b5aa1bced66c80cf869a5c8d0471a467e18ce9cab1. // // Solidity: event log_array(uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray(log types.Log) (*GatewayIntegrationTestLogArray, error) { - event := new(GatewayIntegrationTestLogArray) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogArray(log types.Log) (*GatewayEVMZEVMTestLogArray, error) { + event := new(GatewayEVMZEVMTestLogArray) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArray0Iterator struct { - Event *GatewayIntegrationTestLogArray0 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogArray0Iterator is returned from FilterLogArray0 and is used to iterate over the raw logs and unpacked data for LogArray0 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArray0Iterator struct { + Event *GatewayEVMZEVMTestLogArray0 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2504,7 +2504,7 @@ type GatewayIntegrationTestLogArray0Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogArray0Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogArray0Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2513,7 +2513,7 @@ func (it *GatewayIntegrationTestLogArray0Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray0) + it.Event = new(GatewayEVMZEVMTestLogArray0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2528,7 +2528,7 @@ func (it *GatewayIntegrationTestLogArray0Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray0) + it.Event = new(GatewayEVMZEVMTestLogArray0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2544,19 +2544,19 @@ func (it *GatewayIntegrationTestLogArray0Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogArray0Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogArray0Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogArray0Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogArray0Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogArray0 represents a LogArray0 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArray0 struct { +// GatewayEVMZEVMTestLogArray0 represents a LogArray0 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArray0 struct { Val []*big.Int Raw types.Log // Blockchain specific contextual infos } @@ -2564,21 +2564,21 @@ type GatewayIntegrationTestLogArray0 struct { // FilterLogArray0 is a free log retrieval operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. // // Solidity: event log_array(int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArray0Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogArray0(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogArray0Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array0") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_array0") if err != nil { return nil, err } - return &GatewayIntegrationTestLogArray0Iterator{contract: _GatewayIntegrationTest.contract, event: "log_array0", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogArray0Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_array0", logs: logs, sub: sub}, nil } // WatchLogArray0 is a free log subscription operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. // // Solidity: event log_array(int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray0) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogArray0(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogArray0) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array0") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_array0") if err != nil { return nil, err } @@ -2588,8 +2588,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray0(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogArray0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array0", log); err != nil { + event := new(GatewayEVMZEVMTestLogArray0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array0", log); err != nil { return err } event.Raw = log @@ -2613,18 +2613,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray0(op // ParseLogArray0 is a log parse operation binding the contract event 0x890a82679b470f2bd82816ed9b161f97d8b967f37fa3647c21d5bf39749e2dd5. // // Solidity: event log_array(int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray0(log types.Log) (*GatewayIntegrationTestLogArray0, error) { - event := new(GatewayIntegrationTestLogArray0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array0", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogArray0(log types.Log) (*GatewayEVMZEVMTestLogArray0, error) { + event := new(GatewayEVMZEVMTestLogArray0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array0", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArray1Iterator struct { - Event *GatewayIntegrationTestLogArray1 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogArray1Iterator is returned from FilterLogArray1 and is used to iterate over the raw logs and unpacked data for LogArray1 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArray1Iterator struct { + Event *GatewayEVMZEVMTestLogArray1 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2638,7 +2638,7 @@ type GatewayIntegrationTestLogArray1Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogArray1Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogArray1Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2647,7 +2647,7 @@ func (it *GatewayIntegrationTestLogArray1Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray1) + it.Event = new(GatewayEVMZEVMTestLogArray1) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2662,7 +2662,7 @@ func (it *GatewayIntegrationTestLogArray1Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogArray1) + it.Event = new(GatewayEVMZEVMTestLogArray1) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2678,19 +2678,19 @@ func (it *GatewayIntegrationTestLogArray1Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogArray1Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogArray1Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogArray1Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogArray1Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogArray1 represents a LogArray1 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogArray1 struct { +// GatewayEVMZEVMTestLogArray1 represents a LogArray1 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogArray1 struct { Val []common.Address Raw types.Log // Blockchain specific contextual infos } @@ -2698,21 +2698,21 @@ type GatewayIntegrationTestLogArray1 struct { // FilterLogArray1 is a free log retrieval operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. // // Solidity: event log_array(address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*GatewayIntegrationTestLogArray1Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogArray1(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogArray1Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_array1") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_array1") if err != nil { return nil, err } - return &GatewayIntegrationTestLogArray1Iterator{contract: _GatewayIntegrationTest.contract, event: "log_array1", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogArray1Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_array1", logs: logs, sub: sub}, nil } // WatchLogArray1 is a free log subscription operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. // // Solidity: event log_array(address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogArray1) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogArray1(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogArray1) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_array1") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_array1") if err != nil { return nil, err } @@ -2722,8 +2722,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray1(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogArray1) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array1", log); err != nil { + event := new(GatewayEVMZEVMTestLogArray1) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array1", log); err != nil { return err } event.Raw = log @@ -2747,18 +2747,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogArray1(op // ParseLogArray1 is a log parse operation binding the contract event 0x40e1840f5769073d61bd01372d9b75baa9842d5629a0c99ff103be1178a8e9e2. // // Solidity: event log_array(address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogArray1(log types.Log) (*GatewayIntegrationTestLogArray1, error) { - event := new(GatewayIntegrationTestLogArray1) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_array1", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogArray1(log types.Log) (*GatewayEVMZEVMTestLogArray1, error) { + event := new(GatewayEVMZEVMTestLogArray1) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_array1", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogBytesIterator struct { - Event *GatewayIntegrationTestLogBytes // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogBytesIterator is returned from FilterLogBytes and is used to iterate over the raw logs and unpacked data for LogBytes events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogBytesIterator struct { + Event *GatewayEVMZEVMTestLogBytes // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2772,7 +2772,7 @@ type GatewayIntegrationTestLogBytesIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogBytesIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogBytesIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2781,7 +2781,7 @@ func (it *GatewayIntegrationTestLogBytesIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogBytes) + it.Event = new(GatewayEVMZEVMTestLogBytes) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2796,7 +2796,7 @@ func (it *GatewayIntegrationTestLogBytesIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogBytes) + it.Event = new(GatewayEVMZEVMTestLogBytes) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2812,19 +2812,19 @@ func (it *GatewayIntegrationTestLogBytesIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogBytesIterator) Error() error { +func (it *GatewayEVMZEVMTestLogBytesIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogBytesIterator) Close() error { +func (it *GatewayEVMZEVMTestLogBytesIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogBytes represents a LogBytes event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogBytes struct { +// GatewayEVMZEVMTestLogBytes represents a LogBytes event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogBytes struct { Arg0 []byte Raw types.Log // Blockchain specific contextual infos } @@ -2832,21 +2832,21 @@ type GatewayIntegrationTestLogBytes struct { // FilterLogBytes is a free log retrieval operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. // // Solidity: event log_bytes(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*GatewayIntegrationTestLogBytesIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogBytes(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogBytesIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_bytes") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_bytes") if err != nil { return nil, err } - return &GatewayIntegrationTestLogBytesIterator{contract: _GatewayIntegrationTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogBytesIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_bytes", logs: logs, sub: sub}, nil } // WatchLogBytes is a free log subscription operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. // // Solidity: event log_bytes(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogBytes) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogBytes(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogBytes) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_bytes") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_bytes") if err != nil { return nil, err } @@ -2856,8 +2856,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes(opt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogBytes) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes", log); err != nil { + event := new(GatewayEVMZEVMTestLogBytes) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_bytes", log); err != nil { return err } event.Raw = log @@ -2881,18 +2881,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes(opt // ParseLogBytes is a log parse operation binding the contract event 0x23b62ad0584d24a75f0bf3560391ef5659ec6db1269c56e11aa241d637f19b20. // // Solidity: event log_bytes(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogBytes(log types.Log) (*GatewayIntegrationTestLogBytes, error) { - event := new(GatewayIntegrationTestLogBytes) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogBytes(log types.Log) (*GatewayEVMZEVMTestLogBytes, error) { + event := new(GatewayEVMZEVMTestLogBytes) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_bytes", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogBytes32Iterator struct { - Event *GatewayIntegrationTestLogBytes32 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogBytes32Iterator is returned from FilterLogBytes32 and is used to iterate over the raw logs and unpacked data for LogBytes32 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogBytes32Iterator struct { + Event *GatewayEVMZEVMTestLogBytes32 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -2906,7 +2906,7 @@ type GatewayIntegrationTestLogBytes32Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogBytes32Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogBytes32Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -2915,7 +2915,7 @@ func (it *GatewayIntegrationTestLogBytes32Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogBytes32) + it.Event = new(GatewayEVMZEVMTestLogBytes32) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2930,7 +2930,7 @@ func (it *GatewayIntegrationTestLogBytes32Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogBytes32) + it.Event = new(GatewayEVMZEVMTestLogBytes32) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -2946,19 +2946,19 @@ func (it *GatewayIntegrationTestLogBytes32Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogBytes32Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogBytes32Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogBytes32Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogBytes32Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogBytes32 represents a LogBytes32 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogBytes32 struct { +// GatewayEVMZEVMTestLogBytes32 represents a LogBytes32 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogBytes32 struct { Arg0 [32]byte Raw types.Log // Blockchain specific contextual infos } @@ -2966,21 +2966,21 @@ type GatewayIntegrationTestLogBytes32 struct { // FilterLogBytes32 is a free log retrieval operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. // // Solidity: event log_bytes32(bytes32 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*GatewayIntegrationTestLogBytes32Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogBytes32(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogBytes32Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_bytes32") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_bytes32") if err != nil { return nil, err } - return &GatewayIntegrationTestLogBytes32Iterator{contract: _GatewayIntegrationTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogBytes32Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_bytes32", logs: logs, sub: sub}, nil } // WatchLogBytes32 is a free log subscription operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. // // Solidity: event log_bytes32(bytes32 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogBytes32) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogBytes32(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogBytes32) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_bytes32") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_bytes32") if err != nil { return nil, err } @@ -2990,8 +2990,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes32(o select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogBytes32) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { + event := new(GatewayEVMZEVMTestLogBytes32) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { return err } event.Raw = log @@ -3015,18 +3015,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogBytes32(o // ParseLogBytes32 is a log parse operation binding the contract event 0xe81699b85113eea1c73e10588b2b035e55893369632173afd43feb192fac64e3. // // Solidity: event log_bytes32(bytes32 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogBytes32(log types.Log) (*GatewayIntegrationTestLogBytes32, error) { - event := new(GatewayIntegrationTestLogBytes32) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogBytes32(log types.Log) (*GatewayEVMZEVMTestLogBytes32, error) { + event := new(GatewayEVMZEVMTestLogBytes32) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_bytes32", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogIntIterator struct { - Event *GatewayIntegrationTestLogInt // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogIntIterator is returned from FilterLogInt and is used to iterate over the raw logs and unpacked data for LogInt events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogIntIterator struct { + Event *GatewayEVMZEVMTestLogInt // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3040,7 +3040,7 @@ type GatewayIntegrationTestLogIntIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogIntIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogIntIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3049,7 +3049,7 @@ func (it *GatewayIntegrationTestLogIntIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogInt) + it.Event = new(GatewayEVMZEVMTestLogInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3064,7 +3064,7 @@ func (it *GatewayIntegrationTestLogIntIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogInt) + it.Event = new(GatewayEVMZEVMTestLogInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3080,19 +3080,19 @@ func (it *GatewayIntegrationTestLogIntIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogIntIterator) Error() error { +func (it *GatewayEVMZEVMTestLogIntIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogIntIterator) Close() error { +func (it *GatewayEVMZEVMTestLogIntIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogInt represents a LogInt event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogInt struct { +// GatewayEVMZEVMTestLogInt represents a LogInt event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogInt struct { Arg0 *big.Int Raw types.Log // Blockchain specific contextual infos } @@ -3100,21 +3100,21 @@ type GatewayIntegrationTestLogInt struct { // FilterLogInt is a free log retrieval operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. // // Solidity: event log_int(int256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogIntIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogInt(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogIntIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_int") if err != nil { return nil, err } - return &GatewayIntegrationTestLogIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_int", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogIntIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_int", logs: logs, sub: sub}, nil } // WatchLogInt is a free log subscription operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. // // Solidity: event log_int(int256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogInt) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogInt) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_int") if err != nil { return nil, err } @@ -3124,8 +3124,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogInt(opts select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_int", log); err != nil { + event := new(GatewayEVMZEVMTestLogInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_int", log); err != nil { return err } event.Raw = log @@ -3149,18 +3149,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogInt(opts // ParseLogInt is a log parse operation binding the contract event 0x0eb5d52624c8d28ada9fc55a8c502ed5aa3fbe2fb6e91b71b5f376882b1d2fb8. // // Solidity: event log_int(int256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogInt(log types.Log) (*GatewayIntegrationTestLogInt, error) { - event := new(GatewayIntegrationTestLogInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_int", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogInt(log types.Log) (*GatewayEVMZEVMTestLogInt, error) { + event := new(GatewayEVMZEVMTestLogInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_int", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedAddressIterator struct { - Event *GatewayIntegrationTestLogNamedAddress // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedAddressIterator is returned from FilterLogNamedAddress and is used to iterate over the raw logs and unpacked data for LogNamedAddress events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedAddressIterator struct { + Event *GatewayEVMZEVMTestLogNamedAddress // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3174,7 +3174,7 @@ type GatewayIntegrationTestLogNamedAddressIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedAddressIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedAddressIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3183,7 +3183,7 @@ func (it *GatewayIntegrationTestLogNamedAddressIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedAddress) + it.Event = new(GatewayEVMZEVMTestLogNamedAddress) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3198,7 +3198,7 @@ func (it *GatewayIntegrationTestLogNamedAddressIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedAddress) + it.Event = new(GatewayEVMZEVMTestLogNamedAddress) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3214,19 +3214,19 @@ func (it *GatewayIntegrationTestLogNamedAddressIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedAddressIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedAddressIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedAddressIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedAddressIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedAddress represents a LogNamedAddress event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedAddress struct { +// GatewayEVMZEVMTestLogNamedAddress represents a LogNamedAddress event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedAddress struct { Key string Val common.Address Raw types.Log // Blockchain specific contextual infos @@ -3235,21 +3235,21 @@ type GatewayIntegrationTestLogNamedAddress struct { // FilterLogNamedAddress is a free log retrieval operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. // // Solidity: event log_named_address(string key, address val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedAddressIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedAddress(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedAddressIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_address") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_address") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedAddressIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedAddressIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_address", logs: logs, sub: sub}, nil } // WatchLogNamedAddress is a free log subscription operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. // // Solidity: event log_named_address(string key, address val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedAddress) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedAddress(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedAddress) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_address") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_address") if err != nil { return nil, err } @@ -3259,8 +3259,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedAddr select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedAddress) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_address", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedAddress) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_address", log); err != nil { return err } event.Raw = log @@ -3284,18 +3284,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedAddr // ParseLogNamedAddress is a log parse operation binding the contract event 0x9c4e8541ca8f0dc1c413f9108f66d82d3cecb1bddbce437a61caa3175c4cc96f. // // Solidity: event log_named_address(string key, address val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedAddress(log types.Log) (*GatewayIntegrationTestLogNamedAddress, error) { - event := new(GatewayIntegrationTestLogNamedAddress) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_address", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedAddress(log types.Log) (*GatewayEVMZEVMTestLogNamedAddress, error) { + event := new(GatewayEVMZEVMTestLogNamedAddress) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_address", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArrayIterator struct { - Event *GatewayIntegrationTestLogNamedArray // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedArrayIterator is returned from FilterLogNamedArray and is used to iterate over the raw logs and unpacked data for LogNamedArray events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArrayIterator struct { + Event *GatewayEVMZEVMTestLogNamedArray // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3309,7 +3309,7 @@ type GatewayIntegrationTestLogNamedArrayIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedArrayIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedArrayIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3318,7 +3318,7 @@ func (it *GatewayIntegrationTestLogNamedArrayIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray) + it.Event = new(GatewayEVMZEVMTestLogNamedArray) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3333,7 +3333,7 @@ func (it *GatewayIntegrationTestLogNamedArrayIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray) + it.Event = new(GatewayEVMZEVMTestLogNamedArray) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3349,19 +3349,19 @@ func (it *GatewayIntegrationTestLogNamedArrayIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedArrayIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedArrayIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedArrayIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedArrayIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedArray represents a LogNamedArray event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArray struct { +// GatewayEVMZEVMTestLogNamedArray represents a LogNamedArray event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArray struct { Key string Val []*big.Int Raw types.Log // Blockchain specific contextual infos @@ -3370,21 +3370,21 @@ type GatewayIntegrationTestLogNamedArray struct { // FilterLogNamedArray is a free log retrieval operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. // // Solidity: event log_named_array(string key, uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArrayIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedArray(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedArrayIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_array") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedArrayIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedArrayIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_array", logs: logs, sub: sub}, nil } // WatchLogNamedArray is a free log subscription operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. // // Solidity: event log_named_array(string key, uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedArray(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedArray) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_array") if err != nil { return nil, err } @@ -3394,8 +3394,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedArray) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedArray) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array", log); err != nil { return err } event.Raw = log @@ -3419,18 +3419,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra // ParseLogNamedArray is a log parse operation binding the contract event 0x00aaa39c9ffb5f567a4534380c737075702e1f7f14107fc95328e3b56c0325fb. // // Solidity: event log_named_array(string key, uint256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray(log types.Log) (*GatewayIntegrationTestLogNamedArray, error) { - event := new(GatewayIntegrationTestLogNamedArray) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedArray(log types.Log) (*GatewayEVMZEVMTestLogNamedArray, error) { + event := new(GatewayEVMZEVMTestLogNamedArray) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArray0Iterator struct { - Event *GatewayIntegrationTestLogNamedArray0 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedArray0Iterator is returned from FilterLogNamedArray0 and is used to iterate over the raw logs and unpacked data for LogNamedArray0 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArray0Iterator struct { + Event *GatewayEVMZEVMTestLogNamedArray0 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3444,7 +3444,7 @@ type GatewayIntegrationTestLogNamedArray0Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedArray0Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedArray0Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3453,7 +3453,7 @@ func (it *GatewayIntegrationTestLogNamedArray0Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray0) + it.Event = new(GatewayEVMZEVMTestLogNamedArray0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3468,7 +3468,7 @@ func (it *GatewayIntegrationTestLogNamedArray0Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray0) + it.Event = new(GatewayEVMZEVMTestLogNamedArray0) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3484,19 +3484,19 @@ func (it *GatewayIntegrationTestLogNamedArray0Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedArray0Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedArray0Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedArray0Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedArray0Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedArray0 represents a LogNamedArray0 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArray0 struct { +// GatewayEVMZEVMTestLogNamedArray0 represents a LogNamedArray0 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArray0 struct { Key string Val []*big.Int Raw types.Log // Blockchain specific contextual infos @@ -3505,21 +3505,21 @@ type GatewayIntegrationTestLogNamedArray0 struct { // FilterLogNamedArray0 is a free log retrieval operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. // // Solidity: event log_named_array(string key, int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArray0Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedArray0(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedArray0Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array0") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_array0") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedArray0Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedArray0Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_array0", logs: logs, sub: sub}, nil } // WatchLogNamedArray0 is a free log subscription operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. // // Solidity: event log_named_array(string key, int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray0) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedArray0(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedArray0) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array0") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_array0") if err != nil { return nil, err } @@ -3529,8 +3529,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedArray0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedArray0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { return err } event.Raw = log @@ -3554,18 +3554,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra // ParseLogNamedArray0 is a log parse operation binding the contract event 0xa73eda09662f46dde729be4611385ff34fe6c44fbbc6f7e17b042b59a3445b57. // // Solidity: event log_named_array(string key, int256[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray0(log types.Log) (*GatewayIntegrationTestLogNamedArray0, error) { - event := new(GatewayIntegrationTestLogNamedArray0) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedArray0(log types.Log) (*GatewayEVMZEVMTestLogNamedArray0, error) { + event := new(GatewayEVMZEVMTestLogNamedArray0) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array0", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArray1Iterator struct { - Event *GatewayIntegrationTestLogNamedArray1 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedArray1Iterator is returned from FilterLogNamedArray1 and is used to iterate over the raw logs and unpacked data for LogNamedArray1 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArray1Iterator struct { + Event *GatewayEVMZEVMTestLogNamedArray1 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3579,7 +3579,7 @@ type GatewayIntegrationTestLogNamedArray1Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedArray1Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedArray1Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3588,7 +3588,7 @@ func (it *GatewayIntegrationTestLogNamedArray1Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray1) + it.Event = new(GatewayEVMZEVMTestLogNamedArray1) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3603,7 +3603,7 @@ func (it *GatewayIntegrationTestLogNamedArray1Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedArray1) + it.Event = new(GatewayEVMZEVMTestLogNamedArray1) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3619,19 +3619,19 @@ func (it *GatewayIntegrationTestLogNamedArray1Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedArray1Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedArray1Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedArray1Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedArray1Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedArray1 represents a LogNamedArray1 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedArray1 struct { +// GatewayEVMZEVMTestLogNamedArray1 represents a LogNamedArray1 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedArray1 struct { Key string Val []common.Address Raw types.Log // Blockchain specific contextual infos @@ -3640,21 +3640,21 @@ type GatewayIntegrationTestLogNamedArray1 struct { // FilterLogNamedArray1 is a free log retrieval operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. // // Solidity: event log_named_array(string key, address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedArray1Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedArray1(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedArray1Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_array1") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_array1") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedArray1Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedArray1Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_array1", logs: logs, sub: sub}, nil } // WatchLogNamedArray1 is a free log subscription operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. // // Solidity: event log_named_array(string key, address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedArray1) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedArray1(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedArray1) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_array1") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_array1") if err != nil { return nil, err } @@ -3664,8 +3664,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedArray1) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedArray1) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { return err } event.Raw = log @@ -3689,18 +3689,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedArra // ParseLogNamedArray1 is a log parse operation binding the contract event 0x3bcfb2ae2e8d132dd1fce7cf278a9a19756a9fceabe470df3bdabb4bc577d1bd. // // Solidity: event log_named_array(string key, address[] val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedArray1(log types.Log) (*GatewayIntegrationTestLogNamedArray1, error) { - event := new(GatewayIntegrationTestLogNamedArray1) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedArray1(log types.Log) (*GatewayEVMZEVMTestLogNamedArray1, error) { + event := new(GatewayEVMZEVMTestLogNamedArray1) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_array1", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedBytesIterator struct { - Event *GatewayIntegrationTestLogNamedBytes // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedBytesIterator is returned from FilterLogNamedBytes and is used to iterate over the raw logs and unpacked data for LogNamedBytes events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedBytesIterator struct { + Event *GatewayEVMZEVMTestLogNamedBytes // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3714,7 +3714,7 @@ type GatewayIntegrationTestLogNamedBytesIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedBytesIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedBytesIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3723,7 +3723,7 @@ func (it *GatewayIntegrationTestLogNamedBytesIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedBytes) + it.Event = new(GatewayEVMZEVMTestLogNamedBytes) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3738,7 +3738,7 @@ func (it *GatewayIntegrationTestLogNamedBytesIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedBytes) + it.Event = new(GatewayEVMZEVMTestLogNamedBytes) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3754,19 +3754,19 @@ func (it *GatewayIntegrationTestLogNamedBytesIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedBytesIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedBytesIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedBytesIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedBytesIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedBytes represents a LogNamedBytes event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedBytes struct { +// GatewayEVMZEVMTestLogNamedBytes represents a LogNamedBytes event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedBytes struct { Key string Val []byte Raw types.Log // Blockchain specific contextual infos @@ -3775,21 +3775,21 @@ type GatewayIntegrationTestLogNamedBytes struct { // FilterLogNamedBytes is a free log retrieval operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. // // Solidity: event log_named_bytes(string key, bytes val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedBytesIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedBytes(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedBytesIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_bytes") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_bytes") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedBytesIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedBytesIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_bytes", logs: logs, sub: sub}, nil } // WatchLogNamedBytes is a free log subscription operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. // // Solidity: event log_named_bytes(string key, bytes val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedBytes) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedBytes(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedBytes) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_bytes") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_bytes") if err != nil { return nil, err } @@ -3799,8 +3799,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedByte select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedBytes) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedBytes) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { return err } event.Raw = log @@ -3824,18 +3824,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedByte // ParseLogNamedBytes is a log parse operation binding the contract event 0xd26e16cad4548705e4c9e2d94f98ee91c289085ee425594fd5635fa2964ccf18. // // Solidity: event log_named_bytes(string key, bytes val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedBytes(log types.Log) (*GatewayIntegrationTestLogNamedBytes, error) { - event := new(GatewayIntegrationTestLogNamedBytes) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedBytes(log types.Log) (*GatewayEVMZEVMTestLogNamedBytes, error) { + event := new(GatewayEVMZEVMTestLogNamedBytes) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_bytes", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedBytes32Iterator struct { - Event *GatewayIntegrationTestLogNamedBytes32 // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedBytes32Iterator is returned from FilterLogNamedBytes32 and is used to iterate over the raw logs and unpacked data for LogNamedBytes32 events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedBytes32Iterator struct { + Event *GatewayEVMZEVMTestLogNamedBytes32 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3849,7 +3849,7 @@ type GatewayIntegrationTestLogNamedBytes32Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedBytes32Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3858,7 +3858,7 @@ func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedBytes32) + it.Event = new(GatewayEVMZEVMTestLogNamedBytes32) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3873,7 +3873,7 @@ func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedBytes32) + it.Event = new(GatewayEVMZEVMTestLogNamedBytes32) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -3889,19 +3889,19 @@ func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedBytes32Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedBytes32Iterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedBytes32Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedBytes32 struct { +// GatewayEVMZEVMTestLogNamedBytes32 represents a LogNamedBytes32 event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedBytes32 struct { Key string Val [32]byte Raw types.Log // Blockchain specific contextual infos @@ -3910,21 +3910,21 @@ type GatewayIntegrationTestLogNamedBytes32 struct { // FilterLogNamedBytes32 is a free log retrieval operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. // // Solidity: event log_named_bytes32(string key, bytes32 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedBytes32Iterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedBytes32(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedBytes32Iterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_bytes32") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_bytes32") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedBytes32Iterator{contract: _GatewayIntegrationTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedBytes32Iterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_bytes32", logs: logs, sub: sub}, nil } // WatchLogNamedBytes32 is a free log subscription operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. // // Solidity: event log_named_bytes32(string key, bytes32 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedBytes32) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedBytes32(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedBytes32) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_bytes32") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_bytes32") if err != nil { return nil, err } @@ -3934,8 +3934,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedByte select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedBytes32) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedBytes32) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { return err } event.Raw = log @@ -3959,18 +3959,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedByte // ParseLogNamedBytes32 is a log parse operation binding the contract event 0xafb795c9c61e4fe7468c386f925d7a5429ecad9c0495ddb8d38d690614d32f99. // // Solidity: event log_named_bytes32(string key, bytes32 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedBytes32(log types.Log) (*GatewayIntegrationTestLogNamedBytes32, error) { - event := new(GatewayIntegrationTestLogNamedBytes32) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedBytes32(log types.Log) (*GatewayEVMZEVMTestLogNamedBytes32, error) { + event := new(GatewayEVMZEVMTestLogNamedBytes32) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_bytes32", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedDecimalIntIterator struct { - Event *GatewayIntegrationTestLogNamedDecimalInt // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedDecimalIntIterator is returned from FilterLogNamedDecimalInt and is used to iterate over the raw logs and unpacked data for LogNamedDecimalInt events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedDecimalIntIterator struct { + Event *GatewayEVMZEVMTestLogNamedDecimalInt // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -3984,7 +3984,7 @@ type GatewayIntegrationTestLogNamedDecimalIntIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedDecimalIntIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -3993,7 +3993,7 @@ func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedDecimalInt) + it.Event = new(GatewayEVMZEVMTestLogNamedDecimalInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4008,7 +4008,7 @@ func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedDecimalInt) + it.Event = new(GatewayEVMZEVMTestLogNamedDecimalInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4024,19 +4024,19 @@ func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedDecimalIntIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedDecimalIntIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedDecimalIntIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedDecimalInt struct { +// GatewayEVMZEVMTestLogNamedDecimalInt represents a LogNamedDecimalInt event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedDecimalInt struct { Key string Val *big.Int Decimals *big.Int @@ -4046,21 +4046,21 @@ type GatewayIntegrationTestLogNamedDecimalInt struct { // FilterLogNamedDecimalInt is a free log retrieval operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. // // Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedDecimalIntIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedDecimalInt(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedDecimalIntIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_decimal_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_decimal_int") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedDecimalIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedDecimalIntIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_decimal_int", logs: logs, sub: sub}, nil } // WatchLogNamedDecimalInt is a free log subscription operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. // // Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedDecimalInt) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedDecimalInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedDecimalInt) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_decimal_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_decimal_int") if err != nil { return nil, err } @@ -4070,8 +4070,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDeci select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedDecimalInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedDecimalInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { return err } event.Raw = log @@ -4095,18 +4095,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDeci // ParseLogNamedDecimalInt is a log parse operation binding the contract event 0x5da6ce9d51151ba10c09a559ef24d520b9dac5c5b8810ae8434e4d0d86411a95. // // Solidity: event log_named_decimal_int(string key, int256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*GatewayIntegrationTestLogNamedDecimalInt, error) { - event := new(GatewayIntegrationTestLogNamedDecimalInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedDecimalInt(log types.Log) (*GatewayEVMZEVMTestLogNamedDecimalInt, error) { + event := new(GatewayEVMZEVMTestLogNamedDecimalInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_decimal_int", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedDecimalUintIterator struct { - Event *GatewayIntegrationTestLogNamedDecimalUint // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedDecimalUintIterator is returned from FilterLogNamedDecimalUint and is used to iterate over the raw logs and unpacked data for LogNamedDecimalUint events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedDecimalUintIterator struct { + Event *GatewayEVMZEVMTestLogNamedDecimalUint // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4120,7 +4120,7 @@ type GatewayIntegrationTestLogNamedDecimalUintIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedDecimalUintIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4129,7 +4129,7 @@ func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedDecimalUint) + it.Event = new(GatewayEVMZEVMTestLogNamedDecimalUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4144,7 +4144,7 @@ func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedDecimalUint) + it.Event = new(GatewayEVMZEVMTestLogNamedDecimalUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4160,19 +4160,19 @@ func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedDecimalUintIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedDecimalUintIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedDecimalUintIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedDecimalUint struct { +// GatewayEVMZEVMTestLogNamedDecimalUint represents a LogNamedDecimalUint event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedDecimalUint struct { Key string Val *big.Int Decimals *big.Int @@ -4182,21 +4182,21 @@ type GatewayIntegrationTestLogNamedDecimalUint struct { // FilterLogNamedDecimalUint is a free log retrieval operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. // // Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedDecimalUintIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedDecimalUint(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedDecimalUintIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_decimal_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_decimal_uint") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedDecimalUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedDecimalUintIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_decimal_uint", logs: logs, sub: sub}, nil } // WatchLogNamedDecimalUint is a free log subscription operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. // // Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedDecimalUint) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedDecimalUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedDecimalUint) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_decimal_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_decimal_uint") if err != nil { return nil, err } @@ -4206,8 +4206,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDeci select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedDecimalUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedDecimalUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { return err } event.Raw = log @@ -4231,18 +4231,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedDeci // ParseLogNamedDecimalUint is a log parse operation binding the contract event 0xeb8ba43ced7537421946bd43e828b8b2b8428927aa8f801c13d934bf11aca57b. // // Solidity: event log_named_decimal_uint(string key, uint256 val, uint256 decimals) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*GatewayIntegrationTestLogNamedDecimalUint, error) { - event := new(GatewayIntegrationTestLogNamedDecimalUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedDecimalUint(log types.Log) (*GatewayEVMZEVMTestLogNamedDecimalUint, error) { + event := new(GatewayEVMZEVMTestLogNamedDecimalUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_decimal_uint", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedIntIterator struct { - Event *GatewayIntegrationTestLogNamedInt // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedIntIterator is returned from FilterLogNamedInt and is used to iterate over the raw logs and unpacked data for LogNamedInt events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedIntIterator struct { + Event *GatewayEVMZEVMTestLogNamedInt // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4256,7 +4256,7 @@ type GatewayIntegrationTestLogNamedIntIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedIntIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedIntIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4265,7 +4265,7 @@ func (it *GatewayIntegrationTestLogNamedIntIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedInt) + it.Event = new(GatewayEVMZEVMTestLogNamedInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4280,7 +4280,7 @@ func (it *GatewayIntegrationTestLogNamedIntIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedInt) + it.Event = new(GatewayEVMZEVMTestLogNamedInt) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4296,19 +4296,19 @@ func (it *GatewayIntegrationTestLogNamedIntIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedIntIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedIntIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedIntIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedIntIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedInt represents a LogNamedInt event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedInt struct { +// GatewayEVMZEVMTestLogNamedInt represents a LogNamedInt event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedInt struct { Key string Val *big.Int Raw types.Log // Blockchain specific contextual infos @@ -4317,21 +4317,21 @@ type GatewayIntegrationTestLogNamedInt struct { // FilterLogNamedInt is a free log retrieval operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. // // Solidity: event log_named_int(string key, int256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedIntIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedInt(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedIntIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_int") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedIntIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedIntIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_int", logs: logs, sub: sub}, nil } // WatchLogNamedInt is a free log subscription operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. // // Solidity: event log_named_int(string key, int256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedInt) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedInt(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedInt) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_int") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_int") if err != nil { return nil, err } @@ -4341,8 +4341,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedInt( select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_int", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_int", log); err != nil { return err } event.Raw = log @@ -4366,18 +4366,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedInt( // ParseLogNamedInt is a log parse operation binding the contract event 0x2fe632779174374378442a8e978bccfbdcc1d6b2b0d81f7e8eb776ab2286f168. // // Solidity: event log_named_int(string key, int256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedInt(log types.Log) (*GatewayIntegrationTestLogNamedInt, error) { - event := new(GatewayIntegrationTestLogNamedInt) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_int", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedInt(log types.Log) (*GatewayEVMZEVMTestLogNamedInt, error) { + event := new(GatewayEVMZEVMTestLogNamedInt) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_int", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedStringIterator struct { - Event *GatewayIntegrationTestLogNamedString // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedStringIterator is returned from FilterLogNamedString and is used to iterate over the raw logs and unpacked data for LogNamedString events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedStringIterator struct { + Event *GatewayEVMZEVMTestLogNamedString // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4391,7 +4391,7 @@ type GatewayIntegrationTestLogNamedStringIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedStringIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedStringIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4400,7 +4400,7 @@ func (it *GatewayIntegrationTestLogNamedStringIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedString) + it.Event = new(GatewayEVMZEVMTestLogNamedString) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4415,7 +4415,7 @@ func (it *GatewayIntegrationTestLogNamedStringIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedString) + it.Event = new(GatewayEVMZEVMTestLogNamedString) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4431,19 +4431,19 @@ func (it *GatewayIntegrationTestLogNamedStringIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedStringIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedStringIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedStringIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedStringIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedString represents a LogNamedString event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedString struct { +// GatewayEVMZEVMTestLogNamedString represents a LogNamedString event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedString struct { Key string Val string Raw types.Log // Blockchain specific contextual infos @@ -4452,21 +4452,21 @@ type GatewayIntegrationTestLogNamedString struct { // FilterLogNamedString is a free log retrieval operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. // // Solidity: event log_named_string(string key, string val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedStringIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedString(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedStringIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_string") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_string") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedStringIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedStringIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_string", logs: logs, sub: sub}, nil } // WatchLogNamedString is a free log subscription operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. // // Solidity: event log_named_string(string key, string val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedString) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedString(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedString) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_string") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_string") if err != nil { return nil, err } @@ -4476,8 +4476,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedStri select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedString) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_string", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedString) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_string", log); err != nil { return err } event.Raw = log @@ -4501,18 +4501,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedStri // ParseLogNamedString is a log parse operation binding the contract event 0x280f4446b28a1372417dda658d30b95b2992b12ac9c7f378535f29a97acf3583. // // Solidity: event log_named_string(string key, string val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedString(log types.Log) (*GatewayIntegrationTestLogNamedString, error) { - event := new(GatewayIntegrationTestLogNamedString) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_string", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedString(log types.Log) (*GatewayEVMZEVMTestLogNamedString, error) { + event := new(GatewayEVMZEVMTestLogNamedString) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_string", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedUintIterator struct { - Event *GatewayIntegrationTestLogNamedUint // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogNamedUintIterator is returned from FilterLogNamedUint and is used to iterate over the raw logs and unpacked data for LogNamedUint events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedUintIterator struct { + Event *GatewayEVMZEVMTestLogNamedUint // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4526,7 +4526,7 @@ type GatewayIntegrationTestLogNamedUintIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogNamedUintIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogNamedUintIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4535,7 +4535,7 @@ func (it *GatewayIntegrationTestLogNamedUintIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedUint) + it.Event = new(GatewayEVMZEVMTestLogNamedUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4550,7 +4550,7 @@ func (it *GatewayIntegrationTestLogNamedUintIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogNamedUint) + it.Event = new(GatewayEVMZEVMTestLogNamedUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4566,19 +4566,19 @@ func (it *GatewayIntegrationTestLogNamedUintIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogNamedUintIterator) Error() error { +func (it *GatewayEVMZEVMTestLogNamedUintIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogNamedUintIterator) Close() error { +func (it *GatewayEVMZEVMTestLogNamedUintIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogNamedUint represents a LogNamedUint event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogNamedUint struct { +// GatewayEVMZEVMTestLogNamedUint represents a LogNamedUint event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogNamedUint struct { Key string Val *big.Int Raw types.Log // Blockchain specific contextual infos @@ -4587,21 +4587,21 @@ type GatewayIntegrationTestLogNamedUint struct { // FilterLogNamedUint is a free log retrieval operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. // // Solidity: event log_named_uint(string key, uint256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogNamedUintIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogNamedUint(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogNamedUintIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_named_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_named_uint") if err != nil { return nil, err } - return &GatewayIntegrationTestLogNamedUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogNamedUintIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_named_uint", logs: logs, sub: sub}, nil } // WatchLogNamedUint is a free log subscription operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. // // Solidity: event log_named_uint(string key, uint256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogNamedUint) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogNamedUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogNamedUint) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_named_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_named_uint") if err != nil { return nil, err } @@ -4611,8 +4611,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedUint select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogNamedUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { + event := new(GatewayEVMZEVMTestLogNamedUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { return err } event.Raw = log @@ -4636,18 +4636,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogNamedUint // ParseLogNamedUint is a log parse operation binding the contract event 0xb2de2fbe801a0df6c0cbddfd448ba3c41d48a040ca35c56c8196ef0fcae721a8. // // Solidity: event log_named_uint(string key, uint256 val) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogNamedUint(log types.Log) (*GatewayIntegrationTestLogNamedUint, error) { - event := new(GatewayIntegrationTestLogNamedUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogNamedUint(log types.Log) (*GatewayEVMZEVMTestLogNamedUint, error) { + event := new(GatewayEVMZEVMTestLogNamedUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_named_uint", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogStringIterator struct { - Event *GatewayIntegrationTestLogString // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogStringIterator is returned from FilterLogString and is used to iterate over the raw logs and unpacked data for LogString events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogStringIterator struct { + Event *GatewayEVMZEVMTestLogString // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4661,7 +4661,7 @@ type GatewayIntegrationTestLogStringIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogStringIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogStringIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4670,7 +4670,7 @@ func (it *GatewayIntegrationTestLogStringIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogString) + it.Event = new(GatewayEVMZEVMTestLogString) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4685,7 +4685,7 @@ func (it *GatewayIntegrationTestLogStringIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogString) + it.Event = new(GatewayEVMZEVMTestLogString) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4701,19 +4701,19 @@ func (it *GatewayIntegrationTestLogStringIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogStringIterator) Error() error { +func (it *GatewayEVMZEVMTestLogStringIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogStringIterator) Close() error { +func (it *GatewayEVMZEVMTestLogStringIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogString represents a LogString event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogString struct { +// GatewayEVMZEVMTestLogString represents a LogString event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogString struct { Arg0 string Raw types.Log // Blockchain specific contextual infos } @@ -4721,21 +4721,21 @@ type GatewayIntegrationTestLogString struct { // FilterLogString is a free log retrieval operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. // // Solidity: event log_string(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogString(opts *bind.FilterOpts) (*GatewayIntegrationTestLogStringIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogString(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogStringIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_string") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_string") if err != nil { return nil, err } - return &GatewayIntegrationTestLogStringIterator{contract: _GatewayIntegrationTest.contract, event: "log_string", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogStringIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_string", logs: logs, sub: sub}, nil } // WatchLogString is a free log subscription operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. // // Solidity: event log_string(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogString) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogString(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogString) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_string") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_string") if err != nil { return nil, err } @@ -4745,8 +4745,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogString(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogString) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_string", log); err != nil { + event := new(GatewayEVMZEVMTestLogString) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_string", log); err != nil { return err } event.Raw = log @@ -4770,18 +4770,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogString(op // ParseLogString is a log parse operation binding the contract event 0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b. // // Solidity: event log_string(string arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogString(log types.Log) (*GatewayIntegrationTestLogString, error) { - event := new(GatewayIntegrationTestLogString) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_string", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogString(log types.Log) (*GatewayEVMZEVMTestLogString, error) { + event := new(GatewayEVMZEVMTestLogString) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_string", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogUintIterator struct { - Event *GatewayIntegrationTestLogUint // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogUintIterator is returned from FilterLogUint and is used to iterate over the raw logs and unpacked data for LogUint events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogUintIterator struct { + Event *GatewayEVMZEVMTestLogUint // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4795,7 +4795,7 @@ type GatewayIntegrationTestLogUintIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogUintIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogUintIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4804,7 +4804,7 @@ func (it *GatewayIntegrationTestLogUintIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogUint) + it.Event = new(GatewayEVMZEVMTestLogUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4819,7 +4819,7 @@ func (it *GatewayIntegrationTestLogUintIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogUint) + it.Event = new(GatewayEVMZEVMTestLogUint) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4835,19 +4835,19 @@ func (it *GatewayIntegrationTestLogUintIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogUintIterator) Error() error { +func (it *GatewayEVMZEVMTestLogUintIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogUintIterator) Close() error { +func (it *GatewayEVMZEVMTestLogUintIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogUint represents a LogUint event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogUint struct { +// GatewayEVMZEVMTestLogUint represents a LogUint event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogUint struct { Arg0 *big.Int Raw types.Log // Blockchain specific contextual infos } @@ -4855,21 +4855,21 @@ type GatewayIntegrationTestLogUint struct { // FilterLogUint is a free log retrieval operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. // // Solidity: event log_uint(uint256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*GatewayIntegrationTestLogUintIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogUint(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogUintIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "log_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "log_uint") if err != nil { return nil, err } - return &GatewayIntegrationTestLogUintIterator{contract: _GatewayIntegrationTest.contract, event: "log_uint", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogUintIterator{contract: _GatewayEVMZEVMTest.contract, event: "log_uint", logs: logs, sub: sub}, nil } // WatchLogUint is a free log subscription operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. // // Solidity: event log_uint(uint256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogUint) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogUint(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogUint) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "log_uint") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "log_uint") if err != nil { return nil, err } @@ -4879,8 +4879,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogUint(opts select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_uint", log); err != nil { + event := new(GatewayEVMZEVMTestLogUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_uint", log); err != nil { return err } event.Raw = log @@ -4904,18 +4904,18 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogUint(opts // ParseLogUint is a log parse operation binding the contract event 0x2cab9790510fd8bdfbd2115288db33fec66691d476efc5427cfd4c0969301755. // // Solidity: event log_uint(uint256 arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogUint(log types.Log) (*GatewayIntegrationTestLogUint, error) { - event := new(GatewayIntegrationTestLogUint) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "log_uint", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogUint(log types.Log) (*GatewayEVMZEVMTestLogUint, error) { + event := new(GatewayEVMZEVMTestLogUint) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "log_uint", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayIntegrationTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogsIterator struct { - Event *GatewayIntegrationTestLogs // Event containing the contract specifics and raw log +// GatewayEVMZEVMTestLogsIterator is returned from FilterLogs and is used to iterate over the raw logs and unpacked data for Logs events raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogsIterator struct { + Event *GatewayEVMZEVMTestLogs // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -4929,7 +4929,7 @@ type GatewayIntegrationTestLogsIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayIntegrationTestLogsIterator) Next() bool { +func (it *GatewayEVMZEVMTestLogsIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -4938,7 +4938,7 @@ func (it *GatewayIntegrationTestLogsIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogs) + it.Event = new(GatewayEVMZEVMTestLogs) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4953,7 +4953,7 @@ func (it *GatewayIntegrationTestLogsIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayIntegrationTestLogs) + it.Event = new(GatewayEVMZEVMTestLogs) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -4969,19 +4969,19 @@ func (it *GatewayIntegrationTestLogsIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayIntegrationTestLogsIterator) Error() error { +func (it *GatewayEVMZEVMTestLogsIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayIntegrationTestLogsIterator) Close() error { +func (it *GatewayEVMZEVMTestLogsIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayIntegrationTestLogs represents a Logs event raised by the GatewayIntegrationTest contract. -type GatewayIntegrationTestLogs struct { +// GatewayEVMZEVMTestLogs represents a Logs event raised by the GatewayEVMZEVMTest contract. +type GatewayEVMZEVMTestLogs struct { Arg0 []byte Raw types.Log // Blockchain specific contextual infos } @@ -4989,21 +4989,21 @@ type GatewayIntegrationTestLogs struct { // FilterLogs is a free log retrieval operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. // // Solidity: event logs(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) FilterLogs(opts *bind.FilterOpts) (*GatewayIntegrationTestLogsIterator, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterLogs(opts *bind.FilterOpts) (*GatewayEVMZEVMTestLogsIterator, error) { - logs, sub, err := _GatewayIntegrationTest.contract.FilterLogs(opts, "logs") + logs, sub, err := _GatewayEVMZEVMTest.contract.FilterLogs(opts, "logs") if err != nil { return nil, err } - return &GatewayIntegrationTestLogsIterator{contract: _GatewayIntegrationTest.contract, event: "logs", logs: logs, sub: sub}, nil + return &GatewayEVMZEVMTestLogsIterator{contract: _GatewayEVMZEVMTest.contract, event: "logs", logs: logs, sub: sub}, nil } // WatchLogs is a free log subscription operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. // // Solidity: event logs(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *GatewayIntegrationTestLogs) (event.Subscription, error) { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchLogs(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestLogs) (event.Subscription, error) { - logs, sub, err := _GatewayIntegrationTest.contract.WatchLogs(opts, "logs") + logs, sub, err := _GatewayEVMZEVMTest.contract.WatchLogs(opts, "logs") if err != nil { return nil, err } @@ -5013,8 +5013,8 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogs(opts *b select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayIntegrationTestLogs) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "logs", log); err != nil { + event := new(GatewayEVMZEVMTestLogs) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "logs", log); err != nil { return err } event.Raw = log @@ -5038,9 +5038,9 @@ func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) WatchLogs(opts *b // ParseLogs is a log parse operation binding the contract event 0xe7950ede0394b9f2ce4a5a1bf5a7e1852411f7e6661b4308c913c4bfd11027e4. // // Solidity: event logs(bytes arg0) -func (_GatewayIntegrationTest *GatewayIntegrationTestFilterer) ParseLogs(log types.Log) (*GatewayIntegrationTestLogs, error) { - event := new(GatewayIntegrationTestLogs) - if err := _GatewayIntegrationTest.contract.UnpackLog(event, "logs", log); err != nil { +func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseLogs(log types.Log) (*GatewayEVMZEVMTestLogs, error) { + event := new(GatewayEVMZEVMTestLogs) + if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "logs", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 0e7c99f2..2fd7dbf0 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -39,7 +39,7 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go new file mode 100644 index 00000000..dde8fa8c --- /dev/null +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go @@ -0,0 +1,181 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package interfaces + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IGatewayZEVMErrorsMetaData contains all meta data concerning the IGatewayZEVMErrors contract. +var IGatewayZEVMErrorsMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"}]", +} + +// IGatewayZEVMErrorsABI is the input ABI used to generate the binding from. +// Deprecated: Use IGatewayZEVMErrorsMetaData.ABI instead. +var IGatewayZEVMErrorsABI = IGatewayZEVMErrorsMetaData.ABI + +// IGatewayZEVMErrors is an auto generated Go binding around an Ethereum contract. +type IGatewayZEVMErrors struct { + IGatewayZEVMErrorsCaller // Read-only binding to the contract + IGatewayZEVMErrorsTransactor // Write-only binding to the contract + IGatewayZEVMErrorsFilterer // Log filterer for contract events +} + +// IGatewayZEVMErrorsCaller is an auto generated read-only Go binding around an Ethereum contract. +type IGatewayZEVMErrorsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMErrorsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IGatewayZEVMErrorsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMErrorsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IGatewayZEVMErrorsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IGatewayZEVMErrorsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IGatewayZEVMErrorsSession struct { + Contract *IGatewayZEVMErrors // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMErrorsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IGatewayZEVMErrorsCallerSession struct { + Contract *IGatewayZEVMErrorsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IGatewayZEVMErrorsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IGatewayZEVMErrorsTransactorSession struct { + Contract *IGatewayZEVMErrorsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IGatewayZEVMErrorsRaw is an auto generated low-level Go binding around an Ethereum contract. +type IGatewayZEVMErrorsRaw struct { + Contract *IGatewayZEVMErrors // Generic contract binding to access the raw methods on +} + +// IGatewayZEVMErrorsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IGatewayZEVMErrorsCallerRaw struct { + Contract *IGatewayZEVMErrorsCaller // Generic read-only contract binding to access the raw methods on +} + +// IGatewayZEVMErrorsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IGatewayZEVMErrorsTransactorRaw struct { + Contract *IGatewayZEVMErrorsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIGatewayZEVMErrors creates a new instance of IGatewayZEVMErrors, bound to a specific deployed contract. +func NewIGatewayZEVMErrors(address common.Address, backend bind.ContractBackend) (*IGatewayZEVMErrors, error) { + contract, err := bindIGatewayZEVMErrors(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IGatewayZEVMErrors{IGatewayZEVMErrorsCaller: IGatewayZEVMErrorsCaller{contract: contract}, IGatewayZEVMErrorsTransactor: IGatewayZEVMErrorsTransactor{contract: contract}, IGatewayZEVMErrorsFilterer: IGatewayZEVMErrorsFilterer{contract: contract}}, nil +} + +// NewIGatewayZEVMErrorsCaller creates a new read-only instance of IGatewayZEVMErrors, bound to a specific deployed contract. +func NewIGatewayZEVMErrorsCaller(address common.Address, caller bind.ContractCaller) (*IGatewayZEVMErrorsCaller, error) { + contract, err := bindIGatewayZEVMErrors(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMErrorsCaller{contract: contract}, nil +} + +// NewIGatewayZEVMErrorsTransactor creates a new write-only instance of IGatewayZEVMErrors, bound to a specific deployed contract. +func NewIGatewayZEVMErrorsTransactor(address common.Address, transactor bind.ContractTransactor) (*IGatewayZEVMErrorsTransactor, error) { + contract, err := bindIGatewayZEVMErrors(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IGatewayZEVMErrorsTransactor{contract: contract}, nil +} + +// NewIGatewayZEVMErrorsFilterer creates a new log filterer instance of IGatewayZEVMErrors, bound to a specific deployed contract. +func NewIGatewayZEVMErrorsFilterer(address common.Address, filterer bind.ContractFilterer) (*IGatewayZEVMErrorsFilterer, error) { + contract, err := bindIGatewayZEVMErrors(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IGatewayZEVMErrorsFilterer{contract: contract}, nil +} + +// bindIGatewayZEVMErrors binds a generic wrapper to an already deployed contract. +func bindIGatewayZEVMErrors(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IGatewayZEVMErrorsMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVMErrors.Contract.IGatewayZEVMErrorsCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVMErrors.Contract.IGatewayZEVMErrorsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVMErrors.Contract.IGatewayZEVMErrorsTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IGatewayZEVMErrors.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IGatewayZEVMErrors.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IGatewayZEVMErrors *IGatewayZEVMErrorsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IGatewayZEVMErrors.Contract.contract.Transact(opts, method, params...) +} diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 9ee8a64e..03680592 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts new file mode 100644 index 00000000..a887755e --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts @@ -0,0 +1,1078 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export declare namespace StdInvariant { + export type FuzzSelectorStruct = { + addr: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzSelectorStructOutput = [string, string[]] & { + addr: string; + selectors: string[]; + }; + + export type FuzzArtifactSelectorStruct = { + artifact: PromiseOrValue; + selectors: PromiseOrValue[]; + }; + + export type FuzzArtifactSelectorStructOutput = [string, string[]] & { + artifact: string; + selectors: string[]; + }; + + export type FuzzInterfaceStruct = { + addr: PromiseOrValue; + artifacts: PromiseOrValue[]; + }; + + export type FuzzInterfaceStructOutput = [string, string[]] & { + addr: string; + artifacts: string[]; + }; +} + +export interface GatewayEVMZEVMTestInterface extends utils.Interface { + functions: { + "IS_TEST()": FunctionFragment; + "excludeArtifacts()": FunctionFragment; + "excludeContracts()": FunctionFragment; + "excludeSelectors()": FunctionFragment; + "excludeSenders()": FunctionFragment; + "failed()": FunctionFragment; + "setUp()": FunctionFragment; + "targetArtifactSelectors()": FunctionFragment; + "targetArtifacts()": FunctionFragment; + "targetContracts()": FunctionFragment; + "targetInterfaces()": FunctionFragment; + "targetSelectors()": FunctionFragment; + "targetSenders()": FunctionFragment; + "testCallReceiverEVMFromZEVM()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "IS_TEST" + | "excludeArtifacts" + | "excludeContracts" + | "excludeSelectors" + | "excludeSenders" + | "failed" + | "setUp" + | "targetArtifactSelectors" + | "targetArtifacts" + | "targetContracts" + | "targetInterfaces" + | "targetSelectors" + | "targetSenders" + | "testCallReceiverEVMFromZEVM" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "IS_TEST", values?: undefined): string; + encodeFunctionData( + functionFragment: "excludeArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "excludeSenders", + values?: undefined + ): string; + encodeFunctionData(functionFragment: "failed", values?: undefined): string; + encodeFunctionData(functionFragment: "setUp", values?: undefined): string; + encodeFunctionData( + functionFragment: "targetArtifactSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetArtifacts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetContracts", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetInterfaces", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSelectors", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "targetSenders", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "testCallReceiverEVMFromZEVM", + values?: undefined + ): string; + + decodeFunctionResult(functionFragment: "IS_TEST", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "excludeArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "excludeSenders", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "failed", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "setUp", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "targetArtifactSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetArtifacts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetContracts", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetInterfaces", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSelectors", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "targetSenders", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "testCallReceiverEVMFromZEVM", + data: BytesLike + ): Result; + + events: { + "Call(address,bytes,bytes)": EventFragment; + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + "log(string)": EventFragment; + "log_address(address)": EventFragment; + "log_array(uint256[])": EventFragment; + "log_array(int256[])": EventFragment; + "log_array(address[])": EventFragment; + "log_bytes(bytes)": EventFragment; + "log_bytes32(bytes32)": EventFragment; + "log_int(int256)": EventFragment; + "log_named_address(string,address)": EventFragment; + "log_named_array(string,uint256[])": EventFragment; + "log_named_array(string,int256[])": EventFragment; + "log_named_array(string,address[])": EventFragment; + "log_named_bytes(string,bytes)": EventFragment; + "log_named_bytes32(string,bytes32)": EventFragment; + "log_named_decimal_int(string,int256,uint256)": EventFragment; + "log_named_decimal_uint(string,uint256,uint256)": EventFragment; + "log_named_int(string,int256)": EventFragment; + "log_named_string(string,string)": EventFragment; + "log_named_uint(string,uint256)": EventFragment; + "log_string(string)": EventFragment; + "log_uint(uint256)": EventFragment; + "logs(bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call(address,bytes,bytes)"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "Call(address,address,bytes)" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_address"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(uint256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(int256[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_array(address[])"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_address"): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,uint256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,int256[])" + ): EventFragment; + getEvent( + nameOrSignatureOrTopic: "log_named_array(string,address[])" + ): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_bytes32"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_decimal_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_int"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_named_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_string"): EventFragment; + getEvent(nameOrSignatureOrTopic: "log_uint"): EventFragment; + getEvent(nameOrSignatureOrTopic: "logs"): EventFragment; +} + +export interface Call_address_bytes_bytes_EventObject { + sender: string; + receiver: string; + message: string; +} +export type Call_address_bytes_bytes_Event = TypedEvent< + [string, string, string], + Call_address_bytes_bytes_EventObject +>; + +export type Call_address_bytes_bytes_EventFilter = + TypedEventFilter; + +export interface Call_address_address_bytes_EventObject { + sender: string; + receiver: string; + payload: string; +} +export type Call_address_address_bytes_Event = TypedEvent< + [string, string, string], + Call_address_address_bytes_EventObject +>; + +export type Call_address_address_bytes_EventFilter = + TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; + message: string; +} +export type WithdrawalEvent = TypedEvent< + [string, string, BigNumber, BigNumber, BigNumber, string], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface logEventObject { + arg0: string; +} +export type logEvent = TypedEvent<[string], logEventObject>; + +export type logEventFilter = TypedEventFilter; + +export interface log_addressEventObject { + arg0: string; +} +export type log_addressEvent = TypedEvent<[string], log_addressEventObject>; + +export type log_addressEventFilter = TypedEventFilter; + +export interface log_array_uint256_array_EventObject { + val: BigNumber[]; +} +export type log_array_uint256_array_Event = TypedEvent< + [BigNumber[]], + log_array_uint256_array_EventObject +>; + +export type log_array_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_array_int256_array_EventObject { + val: BigNumber[]; +} +export type log_array_int256_array_Event = TypedEvent< + [BigNumber[]], + log_array_int256_array_EventObject +>; + +export type log_array_int256_array_EventFilter = + TypedEventFilter; + +export interface log_array_address_array_EventObject { + val: string[]; +} +export type log_array_address_array_Event = TypedEvent< + [string[]], + log_array_address_array_EventObject +>; + +export type log_array_address_array_EventFilter = + TypedEventFilter; + +export interface log_bytesEventObject { + arg0: string; +} +export type log_bytesEvent = TypedEvent<[string], log_bytesEventObject>; + +export type log_bytesEventFilter = TypedEventFilter; + +export interface log_bytes32EventObject { + arg0: string; +} +export type log_bytes32Event = TypedEvent<[string], log_bytes32EventObject>; + +export type log_bytes32EventFilter = TypedEventFilter; + +export interface log_intEventObject { + arg0: BigNumber; +} +export type log_intEvent = TypedEvent<[BigNumber], log_intEventObject>; + +export type log_intEventFilter = TypedEventFilter; + +export interface log_named_addressEventObject { + key: string; + val: string; +} +export type log_named_addressEvent = TypedEvent< + [string, string], + log_named_addressEventObject +>; + +export type log_named_addressEventFilter = + TypedEventFilter; + +export interface log_named_array_string_uint256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_uint256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_uint256_array_EventObject +>; + +export type log_named_array_string_uint256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_int256_array_EventObject { + key: string; + val: BigNumber[]; +} +export type log_named_array_string_int256_array_Event = TypedEvent< + [string, BigNumber[]], + log_named_array_string_int256_array_EventObject +>; + +export type log_named_array_string_int256_array_EventFilter = + TypedEventFilter; + +export interface log_named_array_string_address_array_EventObject { + key: string; + val: string[]; +} +export type log_named_array_string_address_array_Event = TypedEvent< + [string, string[]], + log_named_array_string_address_array_EventObject +>; + +export type log_named_array_string_address_array_EventFilter = + TypedEventFilter; + +export interface log_named_bytesEventObject { + key: string; + val: string; +} +export type log_named_bytesEvent = TypedEvent< + [string, string], + log_named_bytesEventObject +>; + +export type log_named_bytesEventFilter = TypedEventFilter; + +export interface log_named_bytes32EventObject { + key: string; + val: string; +} +export type log_named_bytes32Event = TypedEvent< + [string, string], + log_named_bytes32EventObject +>; + +export type log_named_bytes32EventFilter = + TypedEventFilter; + +export interface log_named_decimal_intEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_intEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_intEventObject +>; + +export type log_named_decimal_intEventFilter = + TypedEventFilter; + +export interface log_named_decimal_uintEventObject { + key: string; + val: BigNumber; + decimals: BigNumber; +} +export type log_named_decimal_uintEvent = TypedEvent< + [string, BigNumber, BigNumber], + log_named_decimal_uintEventObject +>; + +export type log_named_decimal_uintEventFilter = + TypedEventFilter; + +export interface log_named_intEventObject { + key: string; + val: BigNumber; +} +export type log_named_intEvent = TypedEvent< + [string, BigNumber], + log_named_intEventObject +>; + +export type log_named_intEventFilter = TypedEventFilter; + +export interface log_named_stringEventObject { + key: string; + val: string; +} +export type log_named_stringEvent = TypedEvent< + [string, string], + log_named_stringEventObject +>; + +export type log_named_stringEventFilter = + TypedEventFilter; + +export interface log_named_uintEventObject { + key: string; + val: BigNumber; +} +export type log_named_uintEvent = TypedEvent< + [string, BigNumber], + log_named_uintEventObject +>; + +export type log_named_uintEventFilter = TypedEventFilter; + +export interface log_stringEventObject { + arg0: string; +} +export type log_stringEvent = TypedEvent<[string], log_stringEventObject>; + +export type log_stringEventFilter = TypedEventFilter; + +export interface log_uintEventObject { + arg0: BigNumber; +} +export type log_uintEvent = TypedEvent<[BigNumber], log_uintEventObject>; + +export type log_uintEventFilter = TypedEventFilter; + +export interface logsEventObject { + arg0: string; +} +export type logsEvent = TypedEvent<[string], logsEventObject>; + +export type logsEventFilter = TypedEventFilter; + +export interface GatewayEVMZEVMTest extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: GatewayEVMZEVMTestInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + IS_TEST(overrides?: CallOverrides): Promise<[boolean]>; + + excludeArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedArtifacts_: string[] }>; + + excludeContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedContracts_: string[] }>; + + excludeSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + excludedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + excludeSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { excludedSenders_: string[] }>; + + failed(overrides?: CallOverrides): Promise<[boolean]>; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzArtifactSelectorStructOutput[]] & { + targetedArtifactSelectors_: StdInvariant.FuzzArtifactSelectorStructOutput[]; + } + >; + + targetArtifacts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedArtifacts_: string[] }>; + + targetContracts( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedContracts_: string[] }>; + + targetInterfaces( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzInterfaceStructOutput[]] & { + targetedInterfaces_: StdInvariant.FuzzInterfaceStructOutput[]; + } + >; + + targetSelectors( + overrides?: CallOverrides + ): Promise< + [StdInvariant.FuzzSelectorStructOutput[]] & { + targetedSelectors_: StdInvariant.FuzzSelectorStructOutput[]; + } + >; + + targetSenders( + overrides?: CallOverrides + ): Promise<[string[]] & { targetedSenders_: string[] }>; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors( + overrides?: CallOverrides + ): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp(overrides?: CallOverrides): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces( + overrides?: CallOverrides + ): Promise; + + targetSelectors( + overrides?: CallOverrides + ): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM(overrides?: CallOverrides): Promise; + }; + + filters: { + "Call(address,bytes,bytes)"( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): Call_address_bytes_bytes_EventFilter; + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): Call_address_address_bytes_EventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + + "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + + "log(string)"(arg0?: null): logEventFilter; + log(arg0?: null): logEventFilter; + + "log_address(address)"(arg0?: null): log_addressEventFilter; + log_address(arg0?: null): log_addressEventFilter; + + "log_array(uint256[])"(val?: null): log_array_uint256_array_EventFilter; + "log_array(int256[])"(val?: null): log_array_int256_array_EventFilter; + "log_array(address[])"(val?: null): log_array_address_array_EventFilter; + + "log_bytes(bytes)"(arg0?: null): log_bytesEventFilter; + log_bytes(arg0?: null): log_bytesEventFilter; + + "log_bytes32(bytes32)"(arg0?: null): log_bytes32EventFilter; + log_bytes32(arg0?: null): log_bytes32EventFilter; + + "log_int(int256)"(arg0?: null): log_intEventFilter; + log_int(arg0?: null): log_intEventFilter; + + "log_named_address(string,address)"( + key?: null, + val?: null + ): log_named_addressEventFilter; + log_named_address(key?: null, val?: null): log_named_addressEventFilter; + + "log_named_array(string,uint256[])"( + key?: null, + val?: null + ): log_named_array_string_uint256_array_EventFilter; + "log_named_array(string,int256[])"( + key?: null, + val?: null + ): log_named_array_string_int256_array_EventFilter; + "log_named_array(string,address[])"( + key?: null, + val?: null + ): log_named_array_string_address_array_EventFilter; + + "log_named_bytes(string,bytes)"( + key?: null, + val?: null + ): log_named_bytesEventFilter; + log_named_bytes(key?: null, val?: null): log_named_bytesEventFilter; + + "log_named_bytes32(string,bytes32)"( + key?: null, + val?: null + ): log_named_bytes32EventFilter; + log_named_bytes32(key?: null, val?: null): log_named_bytes32EventFilter; + + "log_named_decimal_int(string,int256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + log_named_decimal_int( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_intEventFilter; + + "log_named_decimal_uint(string,uint256,uint256)"( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + log_named_decimal_uint( + key?: null, + val?: null, + decimals?: null + ): log_named_decimal_uintEventFilter; + + "log_named_int(string,int256)"( + key?: null, + val?: null + ): log_named_intEventFilter; + log_named_int(key?: null, val?: null): log_named_intEventFilter; + + "log_named_string(string,string)"( + key?: null, + val?: null + ): log_named_stringEventFilter; + log_named_string(key?: null, val?: null): log_named_stringEventFilter; + + "log_named_uint(string,uint256)"( + key?: null, + val?: null + ): log_named_uintEventFilter; + log_named_uint(key?: null, val?: null): log_named_uintEventFilter; + + "log_string(string)"(arg0?: null): log_stringEventFilter; + log_string(arg0?: null): log_stringEventFilter; + + "log_uint(uint256)"(arg0?: null): log_uintEventFilter; + log_uint(arg0?: null): log_uintEventFilter; + + "logs(bytes)"(arg0?: null): logsEventFilter; + logs(arg0?: null): logsEventFilter; + }; + + estimateGas: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors(overrides?: CallOverrides): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + IS_TEST(overrides?: CallOverrides): Promise; + + excludeArtifacts(overrides?: CallOverrides): Promise; + + excludeContracts(overrides?: CallOverrides): Promise; + + excludeSelectors(overrides?: CallOverrides): Promise; + + excludeSenders(overrides?: CallOverrides): Promise; + + failed(overrides?: CallOverrides): Promise; + + setUp( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + targetArtifactSelectors( + overrides?: CallOverrides + ): Promise; + + targetArtifacts(overrides?: CallOverrides): Promise; + + targetContracts(overrides?: CallOverrides): Promise; + + targetInterfaces(overrides?: CallOverrides): Promise; + + targetSelectors(overrides?: CallOverrides): Promise; + + targetSenders(overrides?: CallOverrides): Promise; + + testCallReceiverEVMFromZEVM( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts new file mode 100644 index 00000000..b6ce7797 --- /dev/null +++ b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { GatewayEVMZEVMTest } from "./GatewayEVMZEVMTest"; diff --git a/typechain-types/contracts/prototypes/test/index.ts b/typechain-types/contracts/prototypes/test/index.ts index 9b2831a4..e4b67888 100644 --- a/typechain-types/contracts/prototypes/test/index.ts +++ b/typechain-types/contracts/prototypes/test/index.ts @@ -3,5 +3,5 @@ /* eslint-disable */ import type * as gatewayEvmTSol from "./GatewayEVM.t.sol"; export type { gatewayEvmTSol }; -import type * as gatewayIntegrationTSol from "./GatewayIntegration.t.sol"; -export type { gatewayIntegrationTSol }; +import type * as gatewayEvmzevmTSol from "./GatewayEVMZEVM.t.sol"; +export type { gatewayEvmzevmTSol }; diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors.ts new file mode 100644 index 00000000..74cfd7ba --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayZEVMErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface IGatewayZEVMErrors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts index 973e26af..736bdfc6 100644 --- a/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -2,4 +2,5 @@ /* tslint:disable */ /* eslint-disable */ export type { IGatewayZEVM } from "./IGatewayZEVM"; +export type { IGatewayZEVMErrors } from "./IGatewayZEVMErrors"; export type { IGatewayZEVMEvents } from "./IGatewayZEVMEvents"; diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts index ea6cea4b..ab3efd9b 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -860,7 +860,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts new file mode 100644 index 00000000..9138d17f --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -0,0 +1,1013 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../../common"; +import type { + GatewayEVMZEVMTest, + GatewayEVMZEVMTestInterface, +} from "../../../../../contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "InsufficientZRC20Amount", + type: "error", + }, + { + inputs: [], + name: "InvalidTarget", + type: "error", + }, + { + inputs: [], + name: "WithdrawalFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20BurnFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20TransferFailed", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Withdrawal", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "", + type: "address", + }, + ], + name: "log_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "log_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "", + type: "bytes32", + }, + ], + name: "log_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "log_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address", + name: "val", + type: "address", + }, + ], + name: "log_named_address", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256[]", + name: "val", + type: "uint256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256[]", + name: "val", + type: "int256[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "address[]", + name: "val", + type: "address[]", + }, + ], + name: "log_named_array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes", + name: "val", + type: "bytes", + }, + ], + name: "log_named_bytes", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "bytes32", + name: "val", + type: "bytes32", + }, + ], + name: "log_named_bytes32", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "decimals", + type: "uint256", + }, + ], + name: "log_named_decimal_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "int256", + name: "val", + type: "int256", + }, + ], + name: "log_named_int", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "val", + type: "string", + }, + ], + name: "log_named_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "key", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "val", + type: "uint256", + }, + ], + name: "log_named_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "", + type: "string", + }, + ], + name: "log_string", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + name: "log_uint", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + name: "logs", + type: "event", + }, + { + inputs: [], + name: "IS_TEST", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeArtifacts", + outputs: [ + { + internalType: "string[]", + name: "excludedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeContracts", + outputs: [ + { + internalType: "address[]", + name: "excludedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "excludedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "excludeSenders", + outputs: [ + { + internalType: "address[]", + name: "excludedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "failed", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "setUp", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "targetArtifactSelectors", + outputs: [ + { + components: [ + { + internalType: "string", + name: "artifact", + type: "string", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzArtifactSelector[]", + name: "targetedArtifactSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetArtifacts", + outputs: [ + { + internalType: "string[]", + name: "targetedArtifacts_", + type: "string[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetContracts", + outputs: [ + { + internalType: "address[]", + name: "targetedContracts_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetInterfaces", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "string[]", + name: "artifacts", + type: "string[]", + }, + ], + internalType: "struct StdInvariant.FuzzInterface[]", + name: "targetedInterfaces_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSelectors", + outputs: [ + { + components: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + { + internalType: "bytes4[]", + name: "selectors", + type: "bytes4[]", + }, + ], + internalType: "struct StdInvariant.FuzzSelector[]", + name: "targetedSelectors_", + type: "tuple[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "targetSenders", + outputs: [ + { + internalType: "address[]", + name: "targetedSenders_", + type: "address[]", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "testCallReceiverEVMFromZEVM", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type GatewayEVMZEVMTestConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: GatewayEVMZEVMTestConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class GatewayEVMZEVMTest__factory extends ContractFactory { + constructor(...args: GatewayEVMZEVMTestConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy(overrides || {}) as Promise; + } + override getDeployTransaction( + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(overrides || {}); + } + override attach(address: string): GatewayEVMZEVMTest { + return super.attach(address) as GatewayEVMZEVMTest; + } + override connect(signer: Signer): GatewayEVMZEVMTest__factory { + return super.connect(signer) as GatewayEVMZEVMTest__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): GatewayEVMZEVMTestInterface { + return new utils.Interface(_abi) as GatewayEVMZEVMTestInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): GatewayEVMZEVMTest { + return new Contract(address, _abi, signerOrProvider) as GatewayEVMZEVMTest; + } +} diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts new file mode 100644 index 00000000..e6bf3cc8 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { GatewayEVMZEVMTest__factory } from "./GatewayEVMZEVMTest__factory"; diff --git a/typechain-types/factories/contracts/prototypes/test/index.ts b/typechain-types/factories/contracts/prototypes/test/index.ts index 57d14c51..f9fd3f38 100644 --- a/typechain-types/factories/contracts/prototypes/test/index.ts +++ b/typechain-types/factories/contracts/prototypes/test/index.ts @@ -2,4 +2,4 @@ /* tslint:disable */ /* eslint-disable */ export * as gatewayEvmTSol from "./GatewayEVM.t.sol"; -export * as gatewayIntegrationTSol from "./GatewayIntegration.t.sol"; +export * as gatewayEvmzevmTSol from "./GatewayEVMZEVM.t.sol"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index 669609d2..0b56ad51 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -487,7 +487,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index 54e177ea..3480361c 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "0x608060405234801561001057600080fd5b50604051610bcd380380610bcd8339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610ab6806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105fd565b61009c565b005b61006a6102af565b6040516100779190610761565b60405180910390f35b61009a6004803603810190610095919061055e565b6102d3565b005b60008383836040516024016100b39392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d92919061077c565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df9190610531565b610215576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161027494939291906107dc565b600060405180830381600087803b15801561028e57600080fd5b505af11580156102a2573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102ea9392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b81526004016103c49291906107a5565b600060405180830381600087803b1580156103de57600080fd5b505af11580156103f2573d6000803e3d6000fd5b505050505050505050565b600061041061040b84610892565b61086d565b90508281526020810184848401111561042c5761042b610a1b565b5b610437848285610974565b509392505050565b600061045261044d846108c3565b61086d565b90508281526020810184848401111561046e5761046d610a1b565b5b610479848285610974565b509392505050565b60008135905061049081610a3b565b92915050565b6000813590506104a581610a52565b92915050565b6000815190506104ba81610a52565b92915050565b600082601f8301126104d5576104d4610a16565b5b81356104e58482602086016103fd565b91505092915050565b600082601f83011261050357610502610a16565b5b813561051384826020860161043f565b91505092915050565b60008135905061052b81610a69565b92915050565b60006020828403121561054757610546610a25565b5b6000610555848285016104ab565b91505092915050565b6000806000806080858703121561057857610577610a25565b5b600085013567ffffffffffffffff81111561059657610595610a20565b5b6105a2878288016104c0565b945050602085013567ffffffffffffffff8111156105c3576105c2610a20565b5b6105cf878288016104ee565b93505060406105e08782880161051c565b92505060606105f187828801610496565b91505092959194509250565b60008060008060008060c0878903121561061a57610619610a25565b5b600087013567ffffffffffffffff81111561063857610637610a20565b5b61064489828a016104c0565b965050602061065589828a0161051c565b955050604061066689828a01610481565b945050606087013567ffffffffffffffff81111561068757610686610a20565b5b61069389828a016104ee565b93505060806106a489828a0161051c565b92505060a06106b589828a01610496565b9150509295509295509295565b6106cb8161092c565b82525050565b6106da8161093e565b82525050565b60006106eb826108f4565b6106f5818561090a565b9350610705818560208601610983565b61070e81610a2a565b840191505092915050565b6000610724826108ff565b61072e818561091b565b935061073e818560208601610983565b61074781610a2a565b840191505092915050565b61075b8161096a565b82525050565b600060208201905061077660008301846106c2565b92915050565b600060408201905061079160008301856106c2565b61079e6020830184610752565b9392505050565b600060408201905081810360008301526107bf81856106e0565b905081810360208301526107d381846106e0565b90509392505050565b600060808201905081810360008301526107f681876106e0565b90506108056020830186610752565b61081260408301856106c2565b818103606083015261082481846106e0565b905095945050505050565b600060608201905081810360008301526108498186610719565b90506108586020830185610752565b61086560408301846106d1565b949350505050565b6000610877610888565b905061088382826109b6565b919050565b6000604051905090565b600067ffffffffffffffff8211156108ad576108ac6109e7565b5b6108b682610a2a565b9050602081019050919050565b600067ffffffffffffffff8211156108de576108dd6109e7565b5b6108e782610a2a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b60006109378261094a565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156109a1578082015181840152602081019050610986565b838111156109b0576000848401525b50505050565b6109bf82610a2a565b810181811067ffffffffffffffff821117156109de576109dd6109e7565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a448161092c565b8114610a4f57600080fd5b50565b610a5b8161093e565b8114610a6657600080fd5b50565b610a728161096a565b8114610a7d57600080fd5b5056fea26469706673582212205b143977db6155828f5d21dccf3e39e1abbc3e6abfa0cfb9b988a47a7ff289c864736f6c63430008070033"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts new file mode 100644 index 00000000..f912a171 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts @@ -0,0 +1,61 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVMErrors, + IGatewayZEVMErrorsInterface, +} from "../../../../../contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors"; + +const _abi = [ + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientZRC20Amount", + type: "error", + }, + { + inputs: [], + name: "InvalidTarget", + type: "error", + }, + { + inputs: [], + name: "WithdrawalFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20BurnFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20TransferFailed", + type: "error", + }, +] as const; + +export class IGatewayZEVMErrors__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMErrorsInterface { + return new utils.Interface(_abi) as IGatewayZEVMErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVMErrors { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVMErrors; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts index aa11647e..0b6212ee 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/index.ts @@ -2,4 +2,5 @@ /* tslint:disable */ /* eslint-disable */ export { IGatewayZEVM__factory } from "./IGatewayZEVM__factory"; +export { IGatewayZEVMErrors__factory } from "./IGatewayZEVMErrors__factory"; export { IGatewayZEVMEvents__factory } from "./IGatewayZEVMEvents__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index f48868c6..57cc124e 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -373,9 +373,9 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "GatewayIntegrationTest", + name: "GatewayEVMZEVMTest", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "GatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -384,6 +384,10 @@ declare module "hardhat/types/runtime" { name: "IGatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IGatewayZEVMErrors", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "IGatewayZEVMEvents", signerOrOptions?: ethers.Signer | FactoryOptions @@ -992,10 +996,10 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "GatewayIntegrationTest", + name: "GatewayEVMZEVMTest", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "GatewayZEVM", address: string, @@ -1006,6 +1010,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IGatewayZEVMErrors", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "IGatewayZEVMEvents", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 24211c0f..eca804b4 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -178,12 +178,14 @@ export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; export type { GatewayEVMTest } from "./contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest"; export { GatewayEVMTest__factory } from "./factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory"; -export type { GatewayIntegrationTest } from "./contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest"; -export { GatewayIntegrationTest__factory } from "./factories/contracts/prototypes/test/GatewayIntegration.t.sol/GatewayIntegrationTest__factory"; +export type { GatewayEVMZEVMTest } from "./contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest"; +export { GatewayEVMZEVMTest__factory } from "./factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; +export type { IGatewayZEVMErrors } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors"; +export { IGatewayZEVMErrors__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory"; export type { IGatewayZEVMEvents } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents"; export { IGatewayZEVMEvents__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory"; export type { SenderZEVM } from "./contracts/prototypes/zevm/SenderZEVM"; From a9ff420f536407c8dd424edec363eb5e6b67b1fe Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 02:34:58 +0200 Subject: [PATCH 63/86] bump node version in ci --- .github/workflows/build.yaml | 2 +- .github/workflows/coverage.yaml | 2 +- .github/workflows/generated-files.yaml | 2 +- .github/workflows/lint.yaml | 2 +- .github/workflows/publish-npm.yaml | 2 +- .github/workflows/test.yaml | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index 7e2ee59e..afd8d666 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -24,7 +24,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install Dependencies diff --git a/.github/workflows/coverage.yaml b/.github/workflows/coverage.yaml index b555771b..1abc1a07 100644 --- a/.github/workflows/coverage.yaml +++ b/.github/workflows/coverage.yaml @@ -24,7 +24,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install Dependencies diff --git a/.github/workflows/generated-files.yaml b/.github/workflows/generated-files.yaml index ad5df4cd..ed523c5a 100644 --- a/.github/workflows/generated-files.yaml +++ b/.github/workflows/generated-files.yaml @@ -23,7 +23,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install dependencies diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index 94c51350..5d4ab567 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -24,7 +24,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install Dependencies diff --git a/.github/workflows/publish-npm.yaml b/.github/workflows/publish-npm.yaml index b33ae05f..677fceec 100644 --- a/.github/workflows/publish-npm.yaml +++ b/.github/workflows/publish-npm.yaml @@ -15,7 +15,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install Dependencies diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 1b97b9c7..485ed4d9 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -24,7 +24,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v3 with: - node-version: "16" + node-version: "18" registry-url: "https://registry.npmjs.org" - name: Install Dependencies From c845f688678964001876ec9fd5007d69c8ca58e6 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 02:40:40 +0200 Subject: [PATCH 64/86] add foundry to ci test --- .github/workflows/test.yaml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 485ed4d9..6251d8bb 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -27,6 +27,9 @@ jobs: node-version: "18" registry-url: "https://registry.npmjs.org" + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + - name: Install Dependencies run: yarn install From 065c0965ebdfa10677378eb3d22de48e2c2c8a94 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 02:44:58 +0200 Subject: [PATCH 65/86] remappings --- remappings.txt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/remappings.txt b/remappings.txt index 95836358..b97ee9cf 100644 --- a/remappings.txt +++ b/remappings.txt @@ -1 +1,2 @@ -@openzeppelin/=node_modules/@openzeppelin/ \ No newline at end of file +@openzeppelin/=node_modules/@openzeppelin/ +forge-std/=lib/forge-std/src/ \ No newline at end of file From 4e3c0c3a09018abbd473357ee1c35384bd552b77 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 03:16:14 +0200 Subject: [PATCH 66/86] submodules in ci test --- .github/workflows/test.yaml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 6251d8bb..4f8de5fb 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -20,6 +20,8 @@ jobs: steps: - name: Checkout Repository uses: actions/checkout@v3 + with: + submodules: recursive - name: Setup Node.js uses: actions/setup-node@v3 From 00a835bacc46ff143c30961fcc27f44ade251dce Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 03:22:41 +0200 Subject: [PATCH 67/86] fix workflows --- .github/workflows/generated-files.yaml | 5 +++++ .github/workflows/lint.yaml | 5 +++++ 2 files changed, 10 insertions(+) diff --git a/.github/workflows/generated-files.yaml b/.github/workflows/generated-files.yaml index ed523c5a..fa7378fe 100644 --- a/.github/workflows/generated-files.yaml +++ b/.github/workflows/generated-files.yaml @@ -19,6 +19,8 @@ jobs: steps: - name: Checkout code uses: actions/checkout@v3 + with: + submodules: recursive - name: Setup Node.js uses: actions/setup-node@v3 @@ -38,6 +40,9 @@ jobs: tar -zxvf geth-alltools-linux-amd64-1.11.5-a38f4108.tar.gz sudo mv geth-alltools-linux-amd64-1.11.5-a38f4108/abigen /usr/local/bin/ + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + - name: Generate Go packages and typechain-types run: | yarn generate diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml index 5d4ab567..e991d8eb 100644 --- a/.github/workflows/lint.yaml +++ b/.github/workflows/lint.yaml @@ -20,6 +20,8 @@ jobs: steps: - name: Checkout Repository uses: actions/checkout@v3 + with: + submodules: recursive - name: Setup Node.js uses: actions/setup-node@v3 @@ -27,6 +29,9 @@ jobs: node-version: "18" registry-url: "https://registry.npmjs.org" + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + - name: Install Dependencies run: yarn install From 1925dd0597dc09fd42cfd3369830bfec6bb026d7 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 03:28:18 +0200 Subject: [PATCH 68/86] lint fix --- contracts/prototypes/test/GatewayEVM.t.sol | 1 - contracts/prototypes/test/GatewayEVMZEVM.t.sol | 1 - 2 files changed, 2 deletions(-) diff --git a/contracts/prototypes/test/GatewayEVM.t.sol b/contracts/prototypes/test/GatewayEVM.t.sol index 474e0589..4391da90 100644 --- a/contracts/prototypes/test/GatewayEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVM.t.sol @@ -11,7 +11,6 @@ import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../evm/interfaces.sol"; -import "forge-std/console.sol"; contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiverEVMEvents { using SafeERC20 for IERC20; diff --git a/contracts/prototypes/test/GatewayEVMZEVM.t.sol b/contracts/prototypes/test/GatewayEVMZEVM.t.sol index 8aa94b7b..731be2df 100644 --- a/contracts/prototypes/test/GatewayEVMZEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVMZEVM.t.sol @@ -19,7 +19,6 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "../evm/interfaces.sol"; import "../zevm/interfaces.sol"; -import "forge-std/console.sol"; contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGatewayZEVMEvents, IGatewayZEVMErrors, IReceiverEVMEvents { // evm From 8e63c451cac9f2df1761e14eceb10403e915f4f1 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 03:37:10 +0200 Subject: [PATCH 69/86] generate and readme --- .../test/gatewayevm.t.sol/gatewayevmtest.go | 2 +- .../gatewayevmzevm.t.sol/gatewayevmzevmtest.go | 2 +- readme.md | 18 ++++++++++++++++++ .../GatewayEVMTest__factory.ts | 2 +- .../GatewayEVMZEVMTest__factory.ts | 2 +- 5 files changed, 22 insertions(+), 4 deletions(-) diff --git a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go index a0763b85..b7168498 100644 --- a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. var GatewayEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60806040526001600c60006101000a81548160ff0219169083151502179055506001601f60006101000a81548160ff02191690831515021790555034801561004657600080fd5b5061807d806100566000396000f3fe60806040523480156200001157600080fd5b5060043610620001005760003560e01c8063916a17c61162000099578063ba414fa6116200006f578063ba414fa61462000243578063e20c9f711462000265578063fa7626d41462000287578063fe7bdbb214620002a95762000100565b8063916a17c614620001dd578063b0464fdc14620001ff578063b5508aa914620002215762000100565b80633e5e3c2311620000db5780633e5e3c2314620001555780633f7286f4146200017757806366d9a9a0146200019957806385226c8114620001bb5762000100565b80630a9254e414620001055780631ed7831c14620001115780632ade38801462000133575b600080fd5b6200010f620002b5565b005b6200011b620007f5565b6040516200012a919062001fc1565b60405180910390f35b6200013d62000885565b6040516200014c91906200202d565b60405180910390f35b6200015f62000a1f565b6040516200016e919062001fc1565b60405180910390f35b6200018162000aaf565b60405162000190919062001fc1565b60405180910390f35b620001a362000b3f565b604051620001b2919062002009565b60405180910390f35b620001c562000cd6565b604051620001d4919062001fe5565b60405180910390f35b620001e762000db9565b604051620001f6919062002051565b60405180910390f35b6200020962000f0c565b60405162000218919062002051565b60405180910390f35b6200022b6200105f565b6040516200023a919062001fe5565b60405180910390f35b6200024d62001142565b6040516200025c919062002075565b60405180910390f35b6200026f62001275565b6040516200027e919062001fc1565b60405180910390f35b6200029162001305565b604051620002a0919062002075565b60405180910390f35b620002b362001318565b005b30602360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550611234602460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550615678602560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200038a90620016d2565b620003959062002133565b604051809103906000f080158015620003b2573d6000803e3d6000fd5b50602260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200040190620016e0565b604051809103906000f0801580156200041e573d6000803e3d6000fd5b50601f60016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516200049090620016ee565b6200049c919062001ea5565b604051809103906000f080158015620004b9573d6000803e3d6000fd5b50602160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c4d66de8602560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b815260040162000579919062001ea5565b600060405180830381600087803b1580156200059457600080fd5b505af1158015620005a9573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ae7a3a6f602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200062c919062001ea5565b600060405180830381600087803b1580156200064757600080fd5b505af11580156200065c573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b8152600401620006e492919062001f23565b600060405180830381600087803b158015620006ff57600080fd5b505af115801562000714573d6000803e3d6000fd5b50505050602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166207a1206040518363ffffffff1660e01b81526004016200079c92919062001f50565b602060405180830381600087803b158015620007b757600080fd5b505af1158015620007cc573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620007f29190620017a8565b50565b606060168054806020026020016040519081016040528092919081815260200182805480156200087b57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000830575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020016000905b8282101562000a1657838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020016000905b82821015620009fe5783829060005260206000200180546200096a906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000998906200248b565b8015620009e95780601f10620009bd57610100808354040283529160200191620009e9565b820191906000526020600020905b815481529060010190602001808311620009cb57829003601f168201915b50505050508152602001906001019062000948565b505050508152505081526020019060010190620008a9565b50505050905090565b6060601880548060200260200160405190810160405280929190818152602001828054801562000aa557602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000a5a575b5050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801562000b3557602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000aea575b5050505050905090565b6060601b805480602002602001604051908101604052809291908181526020016000905b8282101562000ccd578382906000526020600020906002020160405180604001604052908160008201805462000b99906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000bc7906200248b565b801562000c185780601f1062000bec5761010080835404028352916020019162000c18565b820191906000526020600020905b81548152906001019060200180831162000bfa57829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801562000cb457602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000c605790505b5050505050815250508152602001906001019062000b63565b50505050905090565b6060601a805480602002602001604051908101604052809291908181526020016000905b8282101562000db057838290600052602060002001805462000d1c906200248b565b80601f016020809104026020016040519081016040528092919081815260200182805462000d4a906200248b565b801562000d9b5780601f1062000d6f5761010080835404028352916020019162000d9b565b820191906000526020600020905b81548152906001019060200180831162000d7d57829003601f168201915b50505050508152602001906001019062000cfa565b50505050905090565b6060601d805480602002602001604051908101604052809291908181526020016000905b8282101562000f0357838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020016001820180548060200260200160405190810160405280929190818152602001828054801562000eea57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000e965790505b5050505050815250508152602001906001019062000ddd565b50505050905090565b6060601c805480602002602001604051908101604052809291908181526020016000905b828210156200105657838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600182018054806020026020016040519081016040528092919081815260200182805480156200103d57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000fe95790505b5050505050815250508152602001906001019062000f30565b50505050905090565b60606019805480602002602001604051908101604052809291908181526020016000905b8282101562001139578382906000526020600020018054620010a5906200248b565b80601f0160208091040260200160405190810160405280929190818152602001828054620010d3906200248b565b8015620011245780601f10620010f85761010080835404028352916020019162001124565b820191906000526020600020905b8154815290600101906020018083116200110657829003601f168201915b50505050508152602001906001019062001083565b50505050905090565b6000600860009054906101000a900460ff16156200117257600860009054906101000a900460ff16905062001272565b6000801b7f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663667f9d707f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c7f6661696c656400000000000000000000000000000000000000000000000000006040518363ffffffff1660e01b81526004016200121992919062001ec2565b60206040518083038186803b1580156200123257600080fd5b505afa15801562001247573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200126d9190620017da565b141590505b90565b60606015805480602002602001604051908101604052809291908181526020018280548015620012fb57602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620012b0575b5050505050905090565b601f60009054906101000a900460ff1681565b60006040518060400160405280600f81526020017f48656c6c6f2c20466f756e64727921000000000000000000000000000000000081525090506000602a90506000600190506000670de0b6b3a7640000905060008484846040516024016200138493929190620020ef565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663f30c7ba3602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684846040518463ffffffff1660e01b8152600401620014879392919062001f7d565b600060405180830381600087803b158015620014a257600080fd5b505af1158015620014b7573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b81526004016200154595949392919062002092565b600060405180830381600087803b1580156200156057600080fd5b505af115801562001575573d6000803e3d6000fd5b50505050602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f8383604051620015e59291906200216a565b60405180910390a2601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16631cff79cd83602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b81526004016200166f92919062001eef565b6000604051808303818588803b1580156200168957600080fd5b505af11580156200169e573d6000803e3d6000fd5b50505050506040513d6000823e3d601f19601f82011682018060405250810190620016ca91906200180c565b505050505050565b611813806200260183390190565b6131a48062003e1483390190565b6110908062006fb883390190565b6000620017136200170d84620021c7565b6200219e565b9050828152602081018484840111156200173257620017316200255a565b5b6200173f84828562002455565b509392505050565b6000815190506200175881620025cc565b92915050565b6000815190506200176f81620025e6565b92915050565b600082601f8301126200178d576200178c62002555565b5b81516200179f848260208601620016fc565b91505092915050565b600060208284031215620017c157620017c062002564565b5b6000620017d18482850162001747565b91505092915050565b600060208284031215620017f357620017f262002564565b5b600062001803848285016200175e565b91505092915050565b60006020828403121562001825576200182462002564565b5b600082015167ffffffffffffffff8111156200184657620018456200255f565b5b620018548482850162001775565b91505092915050565b60006200186b8383620018e9565b60208301905092915050565b600062001885838362001c86565b60208301905092915050565b60006200189f838362001cfa565b905092915050565b6000620018b5838362001dca565b905092915050565b6000620018cb838362001e12565b905092915050565b6000620018e1838362001e53565b905092915050565b620018f481620023ad565b82525050565b6200190581620023ad565b82525050565b600062001918826200225d565b62001924818562002303565b93506200193183620021fd565b8060005b83811015620019685781516200194c88826200185d565b97506200195983620022b5565b92505060018101905062001935565b5085935050505092915050565b6000620019828262002268565b6200198e818562002314565b93506200199b836200220d565b8060005b83811015620019d2578151620019b6888262001877565b9750620019c383620022c2565b9250506001810190506200199f565b5085935050505092915050565b6000620019ec8262002273565b620019f8818562002325565b93508360208202850162001a0c856200221d565b8060005b8581101562001a4e578484038952815162001a2c858262001891565b945062001a3983620022cf565b925060208a0199505060018101905062001a10565b50829750879550505050505092915050565b600062001a6d8262002273565b62001a79818562002336565b93508360208202850162001a8d856200221d565b8060005b8581101562001acf578484038952815162001aad858262001891565b945062001aba83620022cf565b925060208a0199505060018101905062001a91565b50829750879550505050505092915050565b600062001aee826200227e565b62001afa818562002347565b93508360208202850162001b0e856200222d565b8060005b8581101562001b50578484038952815162001b2e8582620018a7565b945062001b3b83620022dc565b925060208a0199505060018101905062001b12565b50829750879550505050505092915050565b600062001b6f8262002289565b62001b7b818562002358565b93508360208202850162001b8f856200223d565b8060005b8581101562001bd1578484038952815162001baf8582620018bd565b945062001bbc83620022e9565b925060208a0199505060018101905062001b93565b50829750879550505050505092915050565b600062001bf08262002294565b62001bfc818562002369565b93508360208202850162001c10856200224d565b8060005b8581101562001c52578484038952815162001c308582620018d3565b945062001c3d83620022f6565b925060208a0199505060018101905062001c14565b50829750879550505050505092915050565b62001c6f81620023c1565b82525050565b62001c8081620023cd565b82525050565b62001c9181620023d7565b82525050565b600062001ca4826200229f565b62001cb081856200237a565b935062001cc281856020860162002455565b62001ccd8162002569565b840191505092915050565b62001ce3816200242d565b82525050565b62001cf48162002441565b82525050565b600062001d0782620022aa565b62001d1381856200238b565b935062001d2581856020860162002455565b62001d308162002569565b840191505092915050565b600062001d4882620022aa565b62001d5481856200239c565b935062001d6681856020860162002455565b62001d718162002569565b840191505092915050565b600062001d8b6003836200239c565b915062001d98826200257a565b602082019050919050565b600062001db26004836200239c565b915062001dbf82620025a3565b602082019050919050565b6000604083016000830151848203600086015262001de9828262001cfa565b9150506020830151848203602086015262001e05828262001975565b9150508091505092915050565b600060408301600083015162001e2c6000860182620018e9565b506020830151848203602086015262001e468282620019df565b9150508091505092915050565b600060408301600083015162001e6d6000860182620018e9565b506020830151848203602086015262001e87828262001975565b9150508091505092915050565b62001e9f8162002423565b82525050565b600060208201905062001ebc6000830184620018fa565b92915050565b600060408201905062001ed96000830185620018fa565b62001ee8602083018462001c75565b9392505050565b600060408201905062001f066000830185620018fa565b818103602083015262001f1a818462001c97565b90509392505050565b600060408201905062001f3a6000830185620018fa565b62001f49602083018462001cd8565b9392505050565b600060408201905062001f676000830185620018fa565b62001f76602083018462001ce9565b9392505050565b600060608201905062001f946000830186620018fa565b62001fa3602083018562001e94565b818103604083015262001fb7818462001c97565b9050949350505050565b6000602082019050818103600083015262001fdd81846200190b565b905092915050565b6000602082019050818103600083015262002001818462001a60565b905092915050565b6000602082019050818103600083015262002025818462001ae1565b905092915050565b6000602082019050818103600083015262002049818462001b62565b905092915050565b600060208201905081810360008301526200206d818462001be3565b905092915050565b60006020820190506200208c600083018462001c64565b92915050565b600060a082019050620020a9600083018862001c64565b620020b8602083018762001c64565b620020c7604083018662001c64565b620020d6606083018562001c64565b620020e56080830184620018fa565b9695505050505050565b600060608201905081810360008301526200210b818662001d3b565b90506200211c602083018562001e94565b6200212b604083018462001c64565b949350505050565b600060408201905081810360008301526200214e8162001da3565b90508181036020830152620021638162001d7c565b9050919050565b600060408201905062002181600083018562001e94565b818103602083015262002195818462001c97565b90509392505050565b6000620021aa620021bd565b9050620021b88282620024c1565b919050565b6000604051905090565b600067ffffffffffffffff821115620021e557620021e462002526565b5b620021f08262002569565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b6000620023ba8262002403565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006200243a8262002423565b9050919050565b60006200244e8262002423565b9050919050565b60005b838110156200247557808201518184015260208101905062002458565b8381111562002485576000848401525b50505050565b60006002820490506001821680620024a457607f821691505b60208210811415620024bb57620024ba620024f7565b5b50919050565b620024cc8262002569565b810181811067ffffffffffffffff82111715620024ee57620024ed62002526565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f54544b0000000000000000000000000000000000000000000000000000000000600082015250565b7f7465737400000000000000000000000000000000000000000000000000000000600082015250565b620025d781620023c1565b8114620025e357600080fd5b50565b620025f181620023cd565b8114620025fd57600080fd5b5056fe60806040523480156200001157600080fd5b5060405162001813380380620018138339818101604052810190620000379190620001a3565b818181600390805190602001906200005192919062000075565b5080600490805190602001906200006a92919062000075565b5050505050620003ac565b8280546200008390620002bd565b90600052602060002090601f016020900481019282620000a75760008555620000f3565b82601f10620000c257805160ff1916838001178555620000f3565b82800160010185558215620000f3579182015b82811115620000f2578251825591602001919060010190620000d5565b5b50905062000102919062000106565b5090565b5b808211156200012157600081600090555060010162000107565b5090565b60006200013c620001368462000251565b62000228565b9050828152602081018484840111156200015b576200015a6200038c565b5b6200016884828562000287565b509392505050565b600082601f83011262000188576200018762000387565b5b81516200019a84826020860162000125565b91505092915050565b60008060408385031215620001bd57620001bc62000396565b5b600083015167ffffffffffffffff811115620001de57620001dd62000391565b5b620001ec8582860162000170565b925050602083015167ffffffffffffffff81111562000210576200020f62000391565b5b6200021e8582860162000170565b9150509250929050565b60006200023462000247565b9050620002428282620002f3565b919050565b6000604051905090565b600067ffffffffffffffff8211156200026f576200026e62000358565b5b6200027a826200039b565b9050602081019050919050565b60005b83811015620002a75780820151818401526020810190506200028a565b83811115620002b7576000848401525b50505050565b60006002820490506001821680620002d657607f821691505b60208210811415620002ed57620002ec62000329565b5b50919050565b620002fe826200039b565b810181811067ffffffffffffffff8211171562000320576200031f62000358565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b61145780620003bc6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c806340c10f191161007157806340c10f19146101a357806370a08231146101bf57806395d89b41146101ef578063a457c2d71461020d578063a9059cbb1461023d578063dd62ed3e1461026d576100b4565b806306fdde03146100b9578063095ea7b3146100d757806318160ddd1461010757806323b872dd14610125578063313ce567146101555780633950935114610173575b600080fd5b6100c161029d565b6040516100ce9190610ecf565b60405180910390f35b6100f160048036038101906100ec9190610cf6565b61032f565b6040516100fe9190610eb4565b60405180910390f35b61010f610352565b60405161011c9190610ff1565b60405180910390f35b61013f600480360381019061013a9190610ca3565b61035c565b60405161014c9190610eb4565b60405180910390f35b61015d61038b565b60405161016a919061100c565b60405180910390f35b61018d60048036038101906101889190610cf6565b610394565b60405161019a9190610eb4565b60405180910390f35b6101bd60048036038101906101b89190610cf6565b6103cb565b005b6101d960048036038101906101d49190610c36565b6103d9565b6040516101e69190610ff1565b60405180910390f35b6101f7610421565b6040516102049190610ecf565b60405180910390f35b61022760048036038101906102229190610cf6565b6104b3565b6040516102349190610eb4565b60405180910390f35b61025760048036038101906102529190610cf6565b61052a565b6040516102649190610eb4565b60405180910390f35b61028760048036038101906102829190610c63565b61054d565b6040516102949190610ff1565b60405180910390f35b6060600380546102ac90611121565b80601f01602080910402602001604051908101604052809291908181526020018280546102d890611121565b80156103255780601f106102fa57610100808354040283529160200191610325565b820191906000526020600020905b81548152906001019060200180831161030857829003601f168201915b5050505050905090565b60008061033a6105d4565b90506103478185856105dc565b600191505092915050565b6000600254905090565b6000806103676105d4565b90506103748582856107a7565b61037f858585610833565b60019150509392505050565b60006012905090565b60008061039f6105d4565b90506103c08185856103b1858961054d565b6103bb9190611043565b6105dc565b600191505092915050565b6103d58282610aab565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60606004805461043090611121565b80601f016020809104026020016040519081016040528092919081815260200182805461045c90611121565b80156104a95780601f1061047e576101008083540402835291602001916104a9565b820191906000526020600020905b81548152906001019060200180831161048c57829003601f168201915b5050505050905090565b6000806104be6105d4565b905060006104cc828661054d565b905083811015610511576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050890610fb1565b60405180910390fd5b61051e82868684036105dc565b60019250505092915050565b6000806105356105d4565b9050610542818585610833565b600191505092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610f91565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156106bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106b390610f11565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161079a9190610ff1565b60405180910390a3505050565b60006107b3848461054d565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461082d578181101561081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690610f31565b60405180910390fd5b61082c84848484036105dc565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156108a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089a90610f71565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610913576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090a90610ef1565b60405180910390fd5b61091e838383610c02565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156109a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099b90610f51565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a929190610ff1565b60405180910390a3610aa5848484610c07565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610b1b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1290610fd1565b60405180910390fd5b610b2760008383610c02565b8060026000828254610b399190611043565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051610bea9190610ff1565b60405180910390a3610bfe60008383610c07565b5050565b505050565b505050565b600081359050610c1b816113f3565b92915050565b600081359050610c308161140a565b92915050565b600060208284031215610c4c57610c4b6111b1565b5b6000610c5a84828501610c0c565b91505092915050565b60008060408385031215610c7a57610c796111b1565b5b6000610c8885828601610c0c565b9250506020610c9985828601610c0c565b9150509250929050565b600080600060608486031215610cbc57610cbb6111b1565b5b6000610cca86828701610c0c565b9350506020610cdb86828701610c0c565b9250506040610cec86828701610c21565b9150509250925092565b60008060408385031215610d0d57610d0c6111b1565b5b6000610d1b85828601610c0c565b9250506020610d2c85828601610c21565b9150509250929050565b610d3f816110ab565b82525050565b6000610d5082611027565b610d5a8185611032565b9350610d6a8185602086016110ee565b610d73816111b6565b840191505092915050565b6000610d8b602383611032565b9150610d96826111c7565b604082019050919050565b6000610dae602283611032565b9150610db982611216565b604082019050919050565b6000610dd1601d83611032565b9150610ddc82611265565b602082019050919050565b6000610df4602683611032565b9150610dff8261128e565b604082019050919050565b6000610e17602583611032565b9150610e22826112dd565b604082019050919050565b6000610e3a602483611032565b9150610e458261132c565b604082019050919050565b6000610e5d602583611032565b9150610e688261137b565b604082019050919050565b6000610e80601f83611032565b9150610e8b826113ca565b602082019050919050565b610e9f816110d7565b82525050565b610eae816110e1565b82525050565b6000602082019050610ec96000830184610d36565b92915050565b60006020820190508181036000830152610ee98184610d45565b905092915050565b60006020820190508181036000830152610f0a81610d7e565b9050919050565b60006020820190508181036000830152610f2a81610da1565b9050919050565b60006020820190508181036000830152610f4a81610dc4565b9050919050565b60006020820190508181036000830152610f6a81610de7565b9050919050565b60006020820190508181036000830152610f8a81610e0a565b9050919050565b60006020820190508181036000830152610faa81610e2d565b9050919050565b60006020820190508181036000830152610fca81610e50565b9050919050565b60006020820190508181036000830152610fea81610e73565b9050919050565b60006020820190506110066000830184610e96565b92915050565b60006020820190506110216000830184610ea5565b92915050565b600081519050919050565b600082825260208201905092915050565b600061104e826110d7565b9150611059836110d7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561108e5761108d611153565b5b828201905092915050565b60006110a4826110b7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561110c5780820151818401526020810190506110f1565b8381111561111b576000848401525b50505050565b6000600282049050600182168061113957607f821691505b6020821081141561114d5761114c611182565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6113fc81611099565b811461140757600080fd5b50565b611413816110d7565b811461141e57600080fd5b5056fea2646970667358221220d4c96329400732e284f624232c8d7228fc90c00ee7b1a48a85080262107815d864736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c613123610081600039600081816105fc0152818161068b01528181610785015281816108140152610bae01526131236000f3fe6080604052600436106100fe5760003560e01c8063715018a611610095578063c4d66de811610064578063c4d66de8146102e4578063dda79b751461030d578063f2fde38b14610338578063f340fa0114610361578063f45346dc1461037d576100fe565b8063715018a6146102505780638c6f037f146102675780638da5cb5b14610290578063ae7a3a6f146102bb576100fe565b80634f1ef286116100d15780634f1ef286146101a15780635131ab59146101bd57806352d1902d146101fa5780635b11259114610225576100fe565b80631b8b921d146101035780631cff79cd1461012c57806329c59b5d1461015c5780633659cfe614610178575b600080fd5b34801561010f57600080fd5b5061012a60048036038101906101259190612183565b6103a6565b005b61014660048036038101906101419190612183565b610412565b6040516101539190612816565b60405180910390f35b61017660048036038101906101719190612183565b610480565b005b34801561018457600080fd5b5061019f600480360381019061019a91906120ce565b6105fa565b005b6101bb60048036038101906101b691906121e3565b610783565b005b3480156101c957600080fd5b506101e460048036038101906101df91906120fb565b6108c0565b6040516101f19190612816565b60405180910390f35b34801561020657600080fd5b5061020f610baa565b60405161021c91906127d7565b60405180910390f35b34801561023157600080fd5b5061023a610c63565b6040516102479190612733565b60405180910390f35b34801561025c57600080fd5b50610265610c89565b005b34801561027357600080fd5b5061028e60048036038101906102899190612292565b610c9d565b005b34801561029c57600080fd5b506102a5610d99565b6040516102b29190612733565b60405180910390f35b3480156102c757600080fd5b506102e260048036038101906102dd91906120ce565b610dc3565b005b3480156102f057600080fd5b5061030b600480360381019061030691906120ce565b610e8f565b005b34801561031957600080fd5b5061032261107e565b60405161032f9190612733565b60405180910390f35b34801561034457600080fd5b5061035f600480360381019061035a91906120ce565b6110a4565b005b61037b600480360381019061037691906120ce565b611128565b005b34801561038957600080fd5b506103a4600480360381019061039f919061223f565b61129c565b005b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde384846040516104059291906127f2565b60405180910390a3505050565b60606000610421858585611392565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f34868660405161046d93929190612a91565b60405180910390a2809150509392505050565b60003414156104bb576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516105039061271e565b60006040518083038185875af1925050503d8060008114610540576040519150601f19603f3d011682016040523d82523d6000602084013e610545565b606091505b50509050600015158115151415610588576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516105ec9493929190612a15565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610689576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068090612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166106c8611449565b73ffffffffffffffffffffffffffffffffffffffff161461071e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610715906128b5565b60405180910390fd5b610727816114a0565b61078081600067ffffffffffffffff81111561074657610745612c52565b5b6040519080825280601f01601f1916602001820160405280156107785781602001600182028036833780820191505090505b5060006114ab565b50565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610812576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161080990612895565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610851611449565b73ffffffffffffffffffffffffffffffffffffffff16146108a7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089e906128b5565b60405180910390fd5b6108b0826114a0565b6108bc828260016114ab565b5050565b606060008414156108fd576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6109078686611628565b61093d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b81526004016109789291906127ae565b602060405180830381600087803b15801561099257600080fd5b505af11580156109a6573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109ca919061231a565b610a00576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610a0d868585611392565b9050610a198787611628565b610a4f576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610a8a9190612733565b60206040518083038186803b158015610aa257600080fd5b505afa158015610ab6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ada9190612374565b90506000811115610b3357610b3260c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16828a73ffffffffffffffffffffffffffffffffffffffff166116c09092919063ffffffff16565b5b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610b9493929190612a91565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610c3a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c31906128f5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b610c91611746565b610c9b60006117c4565b565b6000841415610cd8576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610d273360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868673ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a486868686604051610d8a9493929190612a15565b60405180910390a35050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614610e4b576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60008060019054906101000a900460ff16159050808015610ec05750600160008054906101000a900460ff1660ff16105b80610eed5750610ecf30611913565b158015610eec5750600160008054906101000a900460ff1660ff16145b5b610f2c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f2390612935565b60405180910390fd5b60016000806101000a81548160ff021916908360ff1602179055508015610f69576001600060016101000a81548160ff0219169083151502179055505b610f71611936565b610f7961198f565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610fe0576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8160ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550801561107a5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860016040516110719190612838565b60405180910390a15b5050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110ac611746565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561111c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161111390612875565b60405180910390fd5b611125816117c4565b50565b6000341415611163576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516111ab9061271e565b60006040518083038185875af1925050503d80600081146111e8576040519150601f19603f3d011682016040523d82523d6000602084013e6111ed565b606091505b50509050600015158115151415611230576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4346000604051611290929190612a55565b60405180910390a35050565b60008214156112d7576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6113263360c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848473ffffffffffffffffffffffffffffffffffffffff1661188a909392919063ffffffff16565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48484604051611385929190612a55565b60405180910390a3505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff163486866040516113bf9291906126ee565b60006040518083038185875af1925050503d80600081146113fc576040519150601f19603f3d011682016040523d82523d6000602084013e611401565b606091505b50915091508161143d576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006114777f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b6114a8611746565b50565b6114d77f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b6119ea565b60000160009054906101000a900460ff16156114fb576114f6836119f4565b611623565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561154157600080fd5b505afa92505050801561157257506040513d601f19601f8201168201806040525081019061156f9190612347565b60015b6115b1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115a890612955565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611616576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161160d90612915565b60405180910390fd5b50611622838383611aad565b5b505050565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611666929190612785565b602060405180830381600087803b15801561168057600080fd5b505af1158015611694573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116b8919061231a565b905092915050565b6117418363a9059cbb60e01b84846040516024016116df9291906127ae565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b505050565b61174e611ba0565b73ffffffffffffffffffffffffffffffffffffffff1661176c610d99565b73ffffffffffffffffffffffffffffffffffffffff16146117c2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016117b990612995565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61190d846323b872dd60e01b8585856040516024016118ab9392919061274e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611ad9565b50505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611985576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161197c906129d5565b60405180910390fd5b61198d611ba8565b565b600060019054906101000a900460ff166119de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016119d5906129d5565b60405180910390fd5b565b6000819050919050565b6000819050919050565b6119fd81611913565b611a3c576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a3390612975565b60405180910390fd5b80611a697f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6119e0565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611ab683611c09565b600082511180611ac35750805b15611ad457611ad28383611c58565b505b505050565b6000611b3b826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff16611c859092919063ffffffff16565b9050600081511115611b9b5780806020019051810190611b5b919061231a565b611b9a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b91906129f5565b60405180910390fd5b5b505050565b600033905090565b600060019054906101000a900460ff16611bf7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611bee906129d5565b60405180910390fd5b611c07611c02611ba0565b6117c4565b565b611c12816119f4565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611c7d83836040518060600160405280602781526020016130c760279139611c9d565b905092915050565b6060611c948484600085611d23565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1685604051611cc79190612707565b600060405180830381855af49150503d8060008114611d02576040519150601f19603f3d011682016040523d82523d6000602084013e611d07565b606091505b5091509150611d1886838387611df0565b925050509392505050565b606082471015611d68576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d5f906128d5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff168587604051611d919190612707565b60006040518083038185875af1925050503d8060008114611dce576040519150601f19603f3d011682016040523d82523d6000602084013e611dd3565b606091505b5091509150611de487838387611e66565b92505050949350505050565b60608315611e5357600083511415611e4b57611e0b85611913565b611e4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e41906129b5565b60405180910390fd5b5b829050611e5e565b611e5d8383611edc565b5b949350505050565b60608315611ec957600083511415611ec157611e8185611f2c565b611ec0576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611eb7906129b5565b60405180910390fd5b5b829050611ed4565b611ed38383611f4f565b5b949350505050565b600082511115611eef5781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f239190612853565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600082511115611f625781518083602001fd5b806040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f969190612853565b60405180910390fd5b6000611fb2611fad84612ae8565b612ac3565b905082815260208101848484011115611fce57611fcd612c90565b5b611fd9848285612bdf565b509392505050565b600081359050611ff08161306a565b92915050565b60008151905061200581613081565b92915050565b60008151905061201a81613098565b92915050565b60008083601f84011261203657612035612c86565b5b8235905067ffffffffffffffff81111561205357612052612c81565b5b60208301915083600182028301111561206f5761206e612c8b565b5b9250929050565b600082601f83011261208b5761208a612c86565b5b813561209b848260208601611f9f565b91505092915050565b6000813590506120b3816130af565b92915050565b6000815190506120c8816130af565b92915050565b6000602082840312156120e4576120e3612c9a565b5b60006120f284828501611fe1565b91505092915050565b60008060008060006080868803121561211757612116612c9a565b5b600061212588828901611fe1565b955050602061213688828901611fe1565b9450506040612147888289016120a4565b935050606086013567ffffffffffffffff81111561216857612167612c95565b5b61217488828901612020565b92509250509295509295909350565b60008060006040848603121561219c5761219b612c9a565b5b60006121aa86828701611fe1565b935050602084013567ffffffffffffffff8111156121cb576121ca612c95565b5b6121d786828701612020565b92509250509250925092565b600080604083850312156121fa576121f9612c9a565b5b600061220885828601611fe1565b925050602083013567ffffffffffffffff81111561222957612228612c95565b5b61223585828601612076565b9150509250929050565b60008060006060848603121561225857612257612c9a565b5b600061226686828701611fe1565b9350506020612277868287016120a4565b925050604061228886828701611fe1565b9150509250925092565b6000806000806000608086880312156122ae576122ad612c9a565b5b60006122bc88828901611fe1565b95505060206122cd888289016120a4565b94505060406122de88828901611fe1565b935050606086013567ffffffffffffffff8111156122ff576122fe612c95565b5b61230b88828901612020565b92509250509295509295909350565b6000602082840312156123305761232f612c9a565b5b600061233e84828501611ff6565b91505092915050565b60006020828403121561235d5761235c612c9a565b5b600061236b8482850161200b565b91505092915050565b60006020828403121561238a57612389612c9a565b5b6000612398848285016120b9565b91505092915050565b6123aa81612b5c565b82525050565b6123b981612b7a565b82525050565b60006123cb8385612b2f565b93506123d8838584612bdf565b6123e183612c9f565b840190509392505050565b60006123f88385612b40565b9350612405838584612bdf565b82840190509392505050565b600061241c82612b19565b6124268185612b2f565b9350612436818560208601612bee565b61243f81612c9f565b840191505092915050565b600061245582612b19565b61245f8185612b40565b935061246f818560208601612bee565b80840191505092915050565b61248481612bbb565b82525050565b61249381612bcd565b82525050565b60006124a482612b24565b6124ae8185612b4b565b93506124be818560208601612bee565b6124c781612c9f565b840191505092915050565b60006124df602683612b4b565b91506124ea82612cb0565b604082019050919050565b6000612502602c83612b4b565b915061250d82612cff565b604082019050919050565b6000612525602c83612b4b565b915061253082612d4e565b604082019050919050565b6000612548602683612b4b565b915061255382612d9d565b604082019050919050565b600061256b603883612b4b565b915061257682612dec565b604082019050919050565b600061258e602983612b4b565b915061259982612e3b565b604082019050919050565b60006125b1602e83612b4b565b91506125bc82612e8a565b604082019050919050565b60006125d4602e83612b4b565b91506125df82612ed9565b604082019050919050565b60006125f7602d83612b4b565b915061260282612f28565b604082019050919050565b600061261a602083612b4b565b915061262582612f77565b602082019050919050565b600061263d600083612b2f565b915061264882612fa0565b600082019050919050565b6000612660600083612b40565b915061266b82612fa0565b600082019050919050565b6000612683601d83612b4b565b915061268e82612fa3565b602082019050919050565b60006126a6602b83612b4b565b91506126b182612fcc565b604082019050919050565b60006126c9602a83612b4b565b91506126d48261301b565b604082019050919050565b6126e881612ba4565b82525050565b60006126fb8284866123ec565b91508190509392505050565b6000612713828461244a565b915081905092915050565b600061272982612653565b9150819050919050565b600060208201905061274860008301846123a1565b92915050565b600060608201905061276360008301866123a1565b61277060208301856123a1565b61277d60408301846126df565b949350505050565b600060408201905061279a60008301856123a1565b6127a7602083018461247b565b9392505050565b60006040820190506127c360008301856123a1565b6127d060208301846126df565b9392505050565b60006020820190506127ec60008301846123b0565b92915050565b6000602082019050818103600083015261280d8184866123bf565b90509392505050565b600060208201905081810360008301526128308184612411565b905092915050565b600060208201905061284d600083018461248a565b92915050565b6000602082019050818103600083015261286d8184612499565b905092915050565b6000602082019050818103600083015261288e816124d2565b9050919050565b600060208201905081810360008301526128ae816124f5565b9050919050565b600060208201905081810360008301526128ce81612518565b9050919050565b600060208201905081810360008301526128ee8161253b565b9050919050565b6000602082019050818103600083015261290e8161255e565b9050919050565b6000602082019050818103600083015261292e81612581565b9050919050565b6000602082019050818103600083015261294e816125a4565b9050919050565b6000602082019050818103600083015261296e816125c7565b9050919050565b6000602082019050818103600083015261298e816125ea565b9050919050565b600060208201905081810360008301526129ae8161260d565b9050919050565b600060208201905081810360008301526129ce81612676565b9050919050565b600060208201905081810360008301526129ee81612699565b9050919050565b60006020820190508181036000830152612a0e816126bc565b9050919050565b6000606082019050612a2a60008301876126df565b612a3760208301866123a1565b8181036040830152612a4a8184866123bf565b905095945050505050565b6000606082019050612a6a60008301856126df565b612a7760208301846123a1565b8181036040830152612a8881612630565b90509392505050565b6000604082019050612aa660008301866126df565b8181036020830152612ab98184866123bf565b9050949350505050565b6000612acd612ade565b9050612ad98282612c21565b919050565b6000604051905090565b600067ffffffffffffffff821115612b0357612b02612c52565b5b612b0c82612c9f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612b6782612b84565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612bc682612ba4565b9050919050565b6000612bd882612bae565b9050919050565b82818337600083830152505050565b60005b83811015612c0c578082015181840152602081019050612bf1565b83811115612c1b576000848401525b50505050565b612c2a82612c9f565b810181811067ffffffffffffffff82111715612c4957612c48612c52565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61307381612b5c565b811461307e57600080fd5b50565b61308a81612b6e565b811461309557600080fd5b50565b6130a181612b7a565b81146130ac57600080fd5b50565b6130b881612ba4565b81146130c357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220154452ab17b7ec6558ae20cf0777deee4780b8e192489db9d10e2ac9e3d689a364736f6c6343000807003360806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea2646970667358221220c6f7c0f9935341aaaabcabf7504d01bbd38a0606132004742a97e6a200eb432564736f6c63430008070033a2646970667358221220f8f2d8477a234d7a8fcaca5977a1df95d9cfab29717831cdaf5b49b35190234764736f6c63430008070033", } // GatewayEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 7a9f8ef9..8c56f223 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. diff --git a/readme.md b/readme.md index 886f320f..25c42190 100644 --- a/readme.md +++ b/readme.md @@ -77,6 +77,24 @@ yarn compile This will compile the Solidity contracts and output the resulting JSON artifacts to the `artifacts` directory. +## Test + +To run v1 tests (hardhat): + +``` +yarn test +``` + +To run v2 tests (hardhat): +``` +yarn test:prototypes +``` + +To run v2 tests (forge): +``` +forge test -vvvv +``` + ## Generating Go Bindings and Contract Addresses To generate Go bindings for the Solidity contracts and fetch, run the following diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts index ab3efd9b..3a79b828 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -860,7 +860,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index 9138d17f..4b5d05b4 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -963,7 +963,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] From 01648d1f0134f92b26b2e28e410000b4f76adcf7 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 04:05:26 +0200 Subject: [PATCH 70/86] cleanup and improve test ci --- .github/workflows/test.yaml | 10 +- contracts/zevm/ZRC20.sol | 1 + contracts/zevm/ZRC20New.sol | 1 + contracts/zevm/interfaces/IZRC20.sol | 17 - package.json | 1 + .../gatewayevmzevmtest.go | 2 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 2 +- .../zevm/senderzevm.sol/senderzevm.go | 2 +- .../zevm/interfaces/izrc20.sol/isystem.go | 367 ------------------ .../zevm/systemcontract.sol/systemcontract.go | 2 +- .../systemcontractmock.go | 2 +- pkg/contracts/zevm/zrc20.sol/zrc20.go | 2 +- pkg/contracts/zevm/zrc20new.sol/zrc20new.go | 2 +- .../zevm/interfaces/IZRC20.sol/index.ts | 1 - .../GatewayEVMZEVMTest__factory.ts | 2 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 2 +- .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../SystemContract__factory.ts | 2 +- .../zevm/ZRC20.sol/ZRC20__factory.ts | 2 +- .../zevm/ZRC20New.sol/ZRC20New__factory.ts | 2 +- .../zevm/interfaces/IZRC20.sol/index.ts | 1 - .../SystemContractMock__factory.ts | 2 +- typechain-types/hardhat.d.ts | 9 - 23 files changed, 26 insertions(+), 410 deletions(-) delete mode 100644 pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml index 4f8de5fb..bc6dd7f3 100644 --- a/.github/workflows/test.yaml +++ b/.github/workflows/test.yaml @@ -35,6 +35,14 @@ jobs: - name: Install Dependencies run: yarn install - - name: Test + - name: Test (hardhat) run: yarn test + + - name: Test v2 (hardhat) + run: yarn test:prototypes + + - name: Test v2 (forge) + run: yarn test:forge + + diff --git a/contracts/zevm/ZRC20.sol b/contracts/zevm/ZRC20.sol index 21a6e5f5..2dd1769f 100644 --- a/contracts/zevm/ZRC20.sol +++ b/contracts/zevm/ZRC20.sol @@ -1,6 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; import "./interfaces/IZRC20.sol"; +import "./interfaces/ISystem.sol"; /** * @dev Custom errors for ZRC20 diff --git a/contracts/zevm/ZRC20New.sol b/contracts/zevm/ZRC20New.sol index adc8fbde..351c6c53 100644 --- a/contracts/zevm/ZRC20New.sol +++ b/contracts/zevm/ZRC20New.sol @@ -1,6 +1,7 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; import "./interfaces/IZRC20.sol"; +import "./interfaces/ISystem.sol"; /** * @dev Custom errors for ZRC20 diff --git a/contracts/zevm/interfaces/IZRC20.sol b/contracts/zevm/interfaces/IZRC20.sol index 6b811cf5..670dedf2 100644 --- a/contracts/zevm/interfaces/IZRC20.sol +++ b/contracts/zevm/interfaces/IZRC20.sol @@ -1,23 +1,6 @@ // SPDX-License-Identifier: MIT pragma solidity 0.8.7; -/** - * @dev Interfaces of SystemContract and ZRC20 to make easier to import. - */ -interface ISystem { - function FUNGIBLE_MODULE_ADDRESS() external view returns (address); - - function wZetaContractAddress() external view returns (address); - - function uniswapv2FactoryAddress() external view returns (address); - - function gasPriceByChainId(uint256 chainID) external view returns (uint256); - - function gasCoinZRC20ByChainId(uint256 chainID) external view returns (address); - - function gasZetaPoolByChainId(uint256 chainID) external view returns (address); -} - interface IZRC20 { function totalSupply() external view returns (uint256); diff --git a/package.json b/package.json index c5fd3a62..06e845db 100644 --- a/package.json +++ b/package.json @@ -90,6 +90,7 @@ "prepublishOnly": "yarn build", "test": "npx hardhat test", "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", + "test:forge": "forge test -vvv", "tsc:watch": "npx tsc --watch", "worker": "npx hardhat run scripts/worker.ts --network localhost" }, diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 8c56f223..258118d3 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 2fd7dbf0..d90a14c0 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -39,7 +39,7 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 03680592..0edd4100 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go b/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go deleted file mode 100644 index f0e5f8d1..00000000 --- a/pkg/contracts/zevm/interfaces/izrc20.sol/isystem.go +++ /dev/null @@ -1,367 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package izrc20 - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ISystemMetaData contains all meta data concerning the ISystem contract. -var ISystemMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", -} - -// ISystemABI is the input ABI used to generate the binding from. -// Deprecated: Use ISystemMetaData.ABI instead. -var ISystemABI = ISystemMetaData.ABI - -// ISystem is an auto generated Go binding around an Ethereum contract. -type ISystem struct { - ISystemCaller // Read-only binding to the contract - ISystemTransactor // Write-only binding to the contract - ISystemFilterer // Log filterer for contract events -} - -// ISystemCaller is an auto generated read-only Go binding around an Ethereum contract. -type ISystemCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ISystemTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ISystemTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ISystemFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ISystemFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ISystemSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ISystemSession struct { - Contract *ISystem // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ISystemCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ISystemCallerSession struct { - Contract *ISystemCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ISystemTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ISystemTransactorSession struct { - Contract *ISystemTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ISystemRaw is an auto generated low-level Go binding around an Ethereum contract. -type ISystemRaw struct { - Contract *ISystem // Generic contract binding to access the raw methods on -} - -// ISystemCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ISystemCallerRaw struct { - Contract *ISystemCaller // Generic read-only contract binding to access the raw methods on -} - -// ISystemTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ISystemTransactorRaw struct { - Contract *ISystemTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewISystem creates a new instance of ISystem, bound to a specific deployed contract. -func NewISystem(address common.Address, backend bind.ContractBackend) (*ISystem, error) { - contract, err := bindISystem(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ISystem{ISystemCaller: ISystemCaller{contract: contract}, ISystemTransactor: ISystemTransactor{contract: contract}, ISystemFilterer: ISystemFilterer{contract: contract}}, nil -} - -// NewISystemCaller creates a new read-only instance of ISystem, bound to a specific deployed contract. -func NewISystemCaller(address common.Address, caller bind.ContractCaller) (*ISystemCaller, error) { - contract, err := bindISystem(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ISystemCaller{contract: contract}, nil -} - -// NewISystemTransactor creates a new write-only instance of ISystem, bound to a specific deployed contract. -func NewISystemTransactor(address common.Address, transactor bind.ContractTransactor) (*ISystemTransactor, error) { - contract, err := bindISystem(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ISystemTransactor{contract: contract}, nil -} - -// NewISystemFilterer creates a new log filterer instance of ISystem, bound to a specific deployed contract. -func NewISystemFilterer(address common.Address, filterer bind.ContractFilterer) (*ISystemFilterer, error) { - contract, err := bindISystem(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ISystemFilterer{contract: contract}, nil -} - -// bindISystem binds a generic wrapper to an already deployed contract. -func bindISystem(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ISystemMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ISystem *ISystemRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ISystem.Contract.ISystemCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ISystem *ISystemRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ISystem.Contract.ISystemTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ISystem *ISystemRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ISystem.Contract.ISystemTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ISystem *ISystemCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ISystem.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ISystem *ISystemTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ISystem.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ISystem *ISystemTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ISystem.Contract.contract.Transact(opts, method, params...) -} - -// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. -// -// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) -func (_ISystem *ISystemCaller) FUNGIBLEMODULEADDRESS(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "FUNGIBLE_MODULE_ADDRESS") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. -// -// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) -func (_ISystem *ISystemSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { - return _ISystem.Contract.FUNGIBLEMODULEADDRESS(&_ISystem.CallOpts) -} - -// FUNGIBLEMODULEADDRESS is a free data retrieval call binding the contract method 0x3ce4a5bc. -// -// Solidity: function FUNGIBLE_MODULE_ADDRESS() view returns(address) -func (_ISystem *ISystemCallerSession) FUNGIBLEMODULEADDRESS() (common.Address, error) { - return _ISystem.Contract.FUNGIBLEMODULEADDRESS(&_ISystem.CallOpts) -} - -// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. -// -// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemCaller) GasCoinZRC20ByChainId(opts *bind.CallOpts, chainID *big.Int) (common.Address, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "gasCoinZRC20ByChainId", chainID) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. -// -// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemSession) GasCoinZRC20ByChainId(chainID *big.Int) (common.Address, error) { - return _ISystem.Contract.GasCoinZRC20ByChainId(&_ISystem.CallOpts, chainID) -} - -// GasCoinZRC20ByChainId is a free data retrieval call binding the contract method 0x0be15547. -// -// Solidity: function gasCoinZRC20ByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemCallerSession) GasCoinZRC20ByChainId(chainID *big.Int) (common.Address, error) { - return _ISystem.Contract.GasCoinZRC20ByChainId(&_ISystem.CallOpts, chainID) -} - -// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. -// -// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) -func (_ISystem *ISystemCaller) GasPriceByChainId(opts *bind.CallOpts, chainID *big.Int) (*big.Int, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "gasPriceByChainId", chainID) - - if err != nil { - return *new(*big.Int), err - } - - out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) - - return out0, err - -} - -// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. -// -// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) -func (_ISystem *ISystemSession) GasPriceByChainId(chainID *big.Int) (*big.Int, error) { - return _ISystem.Contract.GasPriceByChainId(&_ISystem.CallOpts, chainID) -} - -// GasPriceByChainId is a free data retrieval call binding the contract method 0xd7fd7afb. -// -// Solidity: function gasPriceByChainId(uint256 chainID) view returns(uint256) -func (_ISystem *ISystemCallerSession) GasPriceByChainId(chainID *big.Int) (*big.Int, error) { - return _ISystem.Contract.GasPriceByChainId(&_ISystem.CallOpts, chainID) -} - -// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. -// -// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemCaller) GasZetaPoolByChainId(opts *bind.CallOpts, chainID *big.Int) (common.Address, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "gasZetaPoolByChainId", chainID) - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. -// -// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemSession) GasZetaPoolByChainId(chainID *big.Int) (common.Address, error) { - return _ISystem.Contract.GasZetaPoolByChainId(&_ISystem.CallOpts, chainID) -} - -// GasZetaPoolByChainId is a free data retrieval call binding the contract method 0x513a9c05. -// -// Solidity: function gasZetaPoolByChainId(uint256 chainID) view returns(address) -func (_ISystem *ISystemCallerSession) GasZetaPoolByChainId(chainID *big.Int) (common.Address, error) { - return _ISystem.Contract.GasZetaPoolByChainId(&_ISystem.CallOpts, chainID) -} - -// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. -// -// Solidity: function uniswapv2FactoryAddress() view returns(address) -func (_ISystem *ISystemCaller) Uniswapv2FactoryAddress(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "uniswapv2FactoryAddress") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. -// -// Solidity: function uniswapv2FactoryAddress() view returns(address) -func (_ISystem *ISystemSession) Uniswapv2FactoryAddress() (common.Address, error) { - return _ISystem.Contract.Uniswapv2FactoryAddress(&_ISystem.CallOpts) -} - -// Uniswapv2FactoryAddress is a free data retrieval call binding the contract method 0xd936a012. -// -// Solidity: function uniswapv2FactoryAddress() view returns(address) -func (_ISystem *ISystemCallerSession) Uniswapv2FactoryAddress() (common.Address, error) { - return _ISystem.Contract.Uniswapv2FactoryAddress(&_ISystem.CallOpts) -} - -// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. -// -// Solidity: function wZetaContractAddress() view returns(address) -func (_ISystem *ISystemCaller) WZetaContractAddress(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ISystem.contract.Call(opts, &out, "wZetaContractAddress") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. -// -// Solidity: function wZetaContractAddress() view returns(address) -func (_ISystem *ISystemSession) WZetaContractAddress() (common.Address, error) { - return _ISystem.Contract.WZetaContractAddress(&_ISystem.CallOpts) -} - -// WZetaContractAddress is a free data retrieval call binding the contract method 0x569541b9. -// -// Solidity: function wZetaContractAddress() view returns(address) -func (_ISystem *ISystemCallerSession) WZetaContractAddress() (common.Address, error) { - return _ISystem.Contract.WZetaContractAddress(&_ISystem.CallOpts) -} diff --git a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go index 7b1cfa11..e5af549b 100644 --- a/pkg/contracts/zevm/systemcontract.sol/systemcontract.go +++ b/pkg/contracts/zevm/systemcontract.sol/systemcontract.go @@ -39,7 +39,7 @@ type ZContext struct { // SystemContractMetaData contains all meta data concerning the SystemContract contract. var SystemContractMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetConnectorZEVM\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setConnectorZEVMAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"erc20\",\"type\":\"address\"}],\"name\":\"setGasZetaPool\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnectorZEVMAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SystemContractABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go index c6537874..0636e691 100644 --- a/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go +++ b/pkg/contracts/zevm/testing/systemcontractmock.sol/systemcontractmock.go @@ -32,7 +32,7 @@ var ( // SystemContractMockMetaData contains all meta data concerning the SystemContractMock contract. var SystemContractMockMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"wzeta_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Factory_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"uniswapv2Router02_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeIdenticalAddresses\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CantBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasCoin\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"SetGasPrice\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetGasZetaPool\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"SetWZeta\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"SystemContractDeployed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasCoinZRC20ByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasPriceByChainId\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"gasZetaPoolByChainId\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"onCrossChainCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"setGasCoinZRC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"price\",\"type\":\"uint256\"}],\"name\":\"setGasPrice\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"setWZETAContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2FactoryAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"factory\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenA\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"tokenB\",\"type\":\"address\"}],\"name\":\"uniswapv2PairFor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"pair\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"uniswapv2Router02Address\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wZetaContractAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SystemContractMockABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/zrc20.sol/zrc20.go b/pkg/contracts/zevm/zrc20.sol/zrc20.go index 4371221d..ce73d030 100644 --- a/pkg/contracts/zevm/zrc20.sol/zrc20.go +++ b/pkg/contracts/zevm/zrc20.sol/zrc20.go @@ -32,7 +32,7 @@ var ( // ZRC20MetaData contains all meta data concerning the ZRC20 contract. var ZRC20MetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60c06040523480156200001157600080fd5b506040516200272c3803806200272c833981810160405281019062000037919062000319565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614620000b1576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8660069080519060200190620000c99291906200018f565b508560079080519060200190620000e29291906200018f565b5084600860006101000a81548160ff021916908360ff16021790555083608081815250508260028111156200011c576200011b62000556565b5b60a081600281111562000134576200013362000556565b5b60f81b8152505081600181905550806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050505050505062000667565b8280546200019d90620004ea565b90600052602060002090601f016020900481019282620001c157600085556200020d565b82601f10620001dc57805160ff19168380011785556200020d565b828001600101855582156200020d579182015b828111156200020c578251825591602001919060010190620001ef565b5b5090506200021c919062000220565b5090565b5b808211156200023b57600081600090555060010162000221565b5090565b600062000256620002508462000433565b6200040a565b905082815260208101848484011115620002755762000274620005e8565b5b62000282848285620004b4565b509392505050565b6000815190506200029b8162000608565b92915050565b600081519050620002b28162000622565b92915050565b600082601f830112620002d057620002cf620005e3565b5b8151620002e28482602086016200023f565b91505092915050565b600081519050620002fc8162000633565b92915050565b60008151905062000313816200064d565b92915050565b600080600080600080600060e0888a0312156200033b576200033a620005f2565b5b600088015167ffffffffffffffff8111156200035c576200035b620005ed565b5b6200036a8a828b01620002b8565b975050602088015167ffffffffffffffff8111156200038e576200038d620005ed565b5b6200039c8a828b01620002b8565b9650506040620003af8a828b0162000302565b9550506060620003c28a828b01620002eb565b9450506080620003d58a828b01620002a1565b93505060a0620003e88a828b01620002eb565b92505060c0620003fb8a828b016200028a565b91505092959891949750929550565b60006200041662000429565b905062000424828262000520565b919050565b6000604051905090565b600067ffffffffffffffff821115620004515762000450620005b4565b5b6200045c82620005f7565b9050602081019050919050565b600062000476826200047d565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b83811015620004d4578082015181840152602081019050620004b7565b83811115620004e4576000848401525b50505050565b600060028204905060018216806200050357607f821691505b602082108114156200051a576200051962000585565b5b50919050565b6200052b82620005f7565b810181811067ffffffffffffffff821117156200054d576200054c620005b4565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b620006138162000469565b81146200061f57600080fd5b50565b600381106200063057600080fd5b50565b6200063e816200049d565b81146200064a57600080fd5b50565b6200065881620004a7565b81146200066457600080fd5b50565b60805160a05160f81c61208e6200069e60003960006108d501526000818161081f01528181610ba20152610cd7015261208e6000f3fe608060405234801561001057600080fd5b50600436106101425760003560e01c806385e1f4d0116100b8578063c835d7cc1161007c578063c835d7cc146103a5578063d9eeebed146103c1578063dd62ed3e146103e0578063eddeb12314610410578063f2441b321461042c578063f687d12a1461044a57610142565b806385e1f4d0146102eb57806395d89b4114610309578063a3413d0314610327578063a9059cbb14610345578063c70126261461037557610142565b8063313ce5671161010a578063313ce567146102015780633ce4a5bc1461021f57806342966c681461023d57806347e7ef241461026d5780634d8943bb1461029d57806370a08231146102bb57610142565b806306fdde0314610147578063091d278814610165578063095ea7b31461018357806318160ddd146101b357806323b872dd146101d1575b600080fd5b61014f610466565b60405161015c9190611c04565b60405180910390f35b61016d6104f8565b60405161017a9190611c26565b60405180910390f35b61019d600480360381019061019891906118c5565b6104fe565b6040516101aa9190611b52565b60405180910390f35b6101bb61051c565b6040516101c89190611c26565b60405180910390f35b6101eb60048036038101906101e69190611872565b610526565b6040516101f89190611b52565b60405180910390f35b61020961061e565b6040516102169190611c41565b60405180910390f35b610227610635565b6040516102349190611ad7565b60405180910390f35b6102576004803603810190610252919061198e565b61064d565b6040516102649190611b52565b60405180910390f35b610287600480360381019061028291906118c5565b610662565b6040516102949190611b52565b60405180910390f35b6102a56107ce565b6040516102b29190611c26565b60405180910390f35b6102d560048036038101906102d091906117d8565b6107d4565b6040516102e29190611c26565b60405180910390f35b6102f361081d565b6040516103009190611c26565b60405180910390f35b610311610841565b60405161031e9190611c04565b60405180910390f35b61032f6108d3565b60405161033c9190611be9565b60405180910390f35b61035f600480360381019061035a91906118c5565b6108f7565b60405161036c9190611b52565b60405180910390f35b61038f600480360381019061038a9190611932565b610915565b60405161039c9190611b52565b60405180910390f35b6103bf60048036038101906103ba91906117d8565b610a6b565b005b6103c9610b5e565b6040516103d7929190611b29565b60405180910390f35b6103fa60048036038101906103f59190611832565b610dcb565b6040516104079190611c26565b60405180910390f35b61042a6004803603810190610425919061198e565b610e52565b005b610434610f0c565b6040516104419190611ad7565b60405180910390f35b610464600480360381019061045f919061198e565b610f30565b005b60606006805461047590611e8a565b80601f01602080910402602001604051908101604052809291908181526020018280546104a190611e8a565b80156104ee5780601f106104c3576101008083540402835291602001916104ee565b820191906000526020600020905b8154815290600101906020018083116104d157829003601f168201915b5050505050905090565b60015481565b600061051261050b610fea565b8484610ff2565b6001905092915050565b6000600554905090565b60006105338484846111ab565b6000600460008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600061057e610fea565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050828110156105f5576040517f10bad14700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61061285610601610fea565b858461060d9190611d9a565b610ff2565b60019150509392505050565b6000600860009054906101000a900460ff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b60006106593383611407565b60019050919050565b600073735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614158015610700575060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614155b15610737576040517fddb5de5e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61074183836115bf565b8273ffffffffffffffffffffffffffffffffffffffff167f67fc7bdaed5b0ec550d8706b87d60568ab70c6b781263c70101d54cd1564aab373735b14bb79463307aacbed86daf3322b1e6226ab60405160200161079e9190611abc565b604051602081830303815290604052846040516107bc929190611b6d565b60405180910390a26001905092915050565b60025481565b6000600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b7f000000000000000000000000000000000000000000000000000000000000000081565b60606007805461085090611e8a565b80601f016020809104026020016040519081016040528092919081815260200182805461087c90611e8a565b80156108c95780601f1061089e576101008083540402835291602001916108c9565b820191906000526020600020905b8154815290600101906020018083116108ac57829003601f168201915b5050505050905090565b7f000000000000000000000000000000000000000000000000000000000000000081565b600061090b610904610fea565b84846111ab565b6001905092915050565b6000806000610922610b5e565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b815260040161097793929190611af2565b602060405180830381600087803b15801561099157600080fd5b505af11580156109a5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109c99190611905565b6109ff576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610a093385611407565b3373ffffffffffffffffffffffffffffffffffffffff167f9ffbffc04a397460ee1dbe8c9503e098090567d6b7f4b3c02a8617d800b6d955868684600254604051610a579493929190611b9d565b60405180910390a260019250505092915050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ae4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055507fd55614e962c5fd6ece71614f6348d702468a997a394dd5e5c1677950226d97ae81604051610b539190611ad7565b60405180910390a150565b60008060008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630be155477f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610bdd9190611c26565b60206040518083038186803b158015610bf557600080fd5b505afa158015610c09573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c2d9190611805565b9050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610c96576040517f78fff39600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663d7fd7afb7f00000000000000000000000000000000000000000000000000000000000000006040518263ffffffff1660e01b8152600401610d129190611c26565b60206040518083038186803b158015610d2a57600080fd5b505afa158015610d3e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d6291906119bb565b90506000811415610d9f576040517fe661aed000000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060025460015483610db29190611d40565b610dbc9190611cea565b90508281945094505050509091565b6000600460008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ecb576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806002819055507fef13af88e424b5d15f49c77758542c1938b08b8b95b91ed0751f98ba99000d8f81604051610f019190611c26565b60405180910390a150565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610fa9576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b806001819055507fff5788270f43bfc1ca41c503606d2594aa3023a1a7547de403a3e2f146a4a80a81604051610fdf9190611c26565b60405180910390a150565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611059576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156110c0576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600460008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161119e9190611c26565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415611212576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611279576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156112f7576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816113039190611d9a565b600360008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555081600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546113959190611cea565b925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516113f99190611c26565b60405180910390a350505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561146e576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156114ec576040517ffe382aa700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81816114f89190611d9a565b600360008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816005600082825461154d9190611d9a565b92505081905550600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040516115b29190611c26565b60405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611626576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600560008282546116389190611cea565b9250508190555080600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825461168e9190611cea565b925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040516116f39190611c26565b60405180910390a35050565b600061171261170d84611c81565b611c5c565b90508281526020810184848401111561172e5761172d611fd2565b5b611739848285611e48565b509392505050565b60008135905061175081612013565b92915050565b60008151905061176581612013565b92915050565b60008151905061177a8161202a565b92915050565b600082601f83011261179557611794611fcd565b5b81356117a58482602086016116ff565b91505092915050565b6000813590506117bd81612041565b92915050565b6000815190506117d281612041565b92915050565b6000602082840312156117ee576117ed611fdc565b5b60006117fc84828501611741565b91505092915050565b60006020828403121561181b5761181a611fdc565b5b600061182984828501611756565b91505092915050565b6000806040838503121561184957611848611fdc565b5b600061185785828601611741565b925050602061186885828601611741565b9150509250929050565b60008060006060848603121561188b5761188a611fdc565b5b600061189986828701611741565b93505060206118aa86828701611741565b92505060406118bb868287016117ae565b9150509250925092565b600080604083850312156118dc576118db611fdc565b5b60006118ea85828601611741565b92505060206118fb858286016117ae565b9150509250929050565b60006020828403121561191b5761191a611fdc565b5b60006119298482850161176b565b91505092915050565b6000806040838503121561194957611948611fdc565b5b600083013567ffffffffffffffff81111561196757611966611fd7565b5b61197385828601611780565b9250506020611984858286016117ae565b9150509250929050565b6000602082840312156119a4576119a3611fdc565b5b60006119b2848285016117ae565b91505092915050565b6000602082840312156119d1576119d0611fdc565b5b60006119df848285016117c3565b91505092915050565b6119f181611dce565b82525050565b611a08611a0382611dce565b611eed565b82525050565b611a1781611de0565b82525050565b6000611a2882611cb2565b611a328185611cc8565b9350611a42818560208601611e57565b611a4b81611fe1565b840191505092915050565b611a5f81611e36565b82525050565b6000611a7082611cbd565b611a7a8185611cd9565b9350611a8a818560208601611e57565b611a9381611fe1565b840191505092915050565b611aa781611e1f565b82525050565b611ab681611e29565b82525050565b6000611ac882846119f7565b60148201915081905092915050565b6000602082019050611aec60008301846119e8565b92915050565b6000606082019050611b0760008301866119e8565b611b1460208301856119e8565b611b216040830184611a9e565b949350505050565b6000604082019050611b3e60008301856119e8565b611b4b6020830184611a9e565b9392505050565b6000602082019050611b676000830184611a0e565b92915050565b60006040820190508181036000830152611b878185611a1d565b9050611b966020830184611a9e565b9392505050565b60006080820190508181036000830152611bb78187611a1d565b9050611bc66020830186611a9e565b611bd36040830185611a9e565b611be06060830184611a9e565b95945050505050565b6000602082019050611bfe6000830184611a56565b92915050565b60006020820190508181036000830152611c1e8184611a65565b905092915050565b6000602082019050611c3b6000830184611a9e565b92915050565b6000602082019050611c566000830184611aad565b92915050565b6000611c66611c77565b9050611c728282611ebc565b919050565b6000604051905090565b600067ffffffffffffffff821115611c9c57611c9b611f9e565b5b611ca582611fe1565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b6000611cf582611e1f565b9150611d0083611e1f565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff03821115611d3557611d34611f11565b5b828201905092915050565b6000611d4b82611e1f565b9150611d5683611e1f565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615611d8f57611d8e611f11565b5b828202905092915050565b6000611da582611e1f565b9150611db083611e1f565b925082821015611dc357611dc2611f11565b5b828203905092915050565b6000611dd982611dff565b9050919050565b60008115159050919050565b6000819050611dfa82611fff565b919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000611e4182611dec565b9050919050565b82818337600083830152505050565b60005b83811015611e75578082015181840152602081019050611e5a565b83811115611e84576000848401525b50505050565b60006002820490506001821680611ea257607f821691505b60208210811415611eb657611eb5611f6f565b5b50919050565b611ec582611fe1565b810181811067ffffffffffffffff82111715611ee457611ee3611f9e565b5b80604052505050565b6000611ef882611eff565b9050919050565b6000611f0a82611ff2565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b600381106120105761200f611f40565b5b50565b61201c81611dce565b811461202757600080fd5b50565b61203381611de0565b811461203e57600080fd5b50565b61204a81611e1f565b811461205557600080fd5b5056fea2646970667358221220afef7d1a51c1829fcaf89af9a3239ae43ab2f828aa86ff901f729544637e39d464736f6c63430008070033", } // ZRC20ABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/zevm/zrc20new.sol/zrc20new.go b/pkg/contracts/zevm/zrc20new.sol/zrc20new.go index 728322d3..c1710758 100644 --- a/pkg/contracts/zevm/zrc20new.sol/zrc20new.go +++ b/pkg/contracts/zevm/zrc20new.sol/zrc20new.go @@ -32,7 +32,7 @@ var ( // ZRC20NewMetaData contains all meta data concerning the ZRC20New contract. var ZRC20NewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name_\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol_\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"chainid_\",\"type\":\"uint256\"},{\"internalType\":\"enumCoinType\",\"name\":\"coinType_\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit_\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"systemContractAddress_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"gatewayContractAddress_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSender\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LowBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasCoin\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroGasPrice\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"from\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"UpdatedGasLimit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"UpdatedProtocolFlatFee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"systemContract\",\"type\":\"address\"}],\"name\":\"UpdatedSystemContract\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CHAIN_ID\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"COIN_TYPE\",\"outputs\":[{\"internalType\":\"enumCoinType\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GAS_LIMIT\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"GATEWAY_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PROTOCOL_FLAT_FEE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"SYSTEM_CONTRACT_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"}],\"name\":\"updateGasLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"}],\"name\":\"updateProtocolFlatFee\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"updateSystemContractAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdrawGasFee\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // ZRC20NewABI is the input ABI used to generate the binding from. diff --git a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts index 0a0567e2..603ef6e3 100644 --- a/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts +++ b/typechain-types/contracts/zevm/interfaces/IZRC20.sol/index.ts @@ -1,7 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export type { ISystem } from "./ISystem"; export type { IZRC20 } from "./IZRC20"; export type { IZRC20Metadata } from "./IZRC20Metadata"; export type { ZRC20Events } from "./ZRC20Events"; diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index 4b5d05b4..51673daa 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -963,7 +963,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index 0b56ad51..2e4bc8ac 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -487,7 +487,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index 3480361c..3742ffc2 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts index 5cdfe45d..f75af307 100644 --- a/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts +++ b/typechain-types/factories/contracts/zevm/SystemContract.sol/SystemContract__factory.ts @@ -429,7 +429,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts b/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts index bd26c05d..d80d9991 100644 --- a/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts +++ b/typechain-types/factories/contracts/zevm/ZRC20.sol/ZRC20__factory.ts @@ -626,7 +626,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ZRC20ConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts index 2e4cf605..68398c65 100644 --- a/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts +++ b/typechain-types/factories/contracts/zevm/ZRC20New.sol/ZRC20New__factory.ts @@ -644,7 +644,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ZRC20NewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts index 7d1b6770..98e010d3 100644 --- a/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts +++ b/typechain-types/factories/contracts/zevm/interfaces/IZRC20.sol/index.ts @@ -1,7 +1,6 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export { ISystem__factory } from "./ISystem__factory"; export { IZRC20__factory } from "./IZRC20__factory"; export { IZRC20Metadata__factory } from "./IZRC20Metadata__factory"; export { ZRC20Events__factory } from "./ZRC20Events__factory"; diff --git a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts index 0620b88e..7931276d 100644 --- a/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts +++ b/typechain-types/factories/contracts/zevm/testing/SystemContractMock.sol/SystemContractMock__factory.ts @@ -332,7 +332,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SystemContractMockConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 57cc124e..16dbcf6f 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -416,10 +416,6 @@ declare module "hardhat/types/runtime" { name: "IWETH9", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; - getContractFactory( - name: "ISystem", - signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; getContractFactory( name: "IZRC20", signerOrOptions?: ethers.Signer | FactoryOptions @@ -1050,11 +1046,6 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; - getContractAt( - name: "ISystem", - address: string, - signer?: ethers.Signer - ): Promise; getContractAt( name: "IZRC20", address: string, From b8cc11b760016e7542953bd9b3adacad5c2b70d9 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 20:21:22 +0200 Subject: [PATCH 71/86] add simple connector --- contracts/prototypes/evm/GatewayEVM.sol | 32 +- .../prototypes/evm/GatewayEVMUpgradeTest.sol | 101 ++- contracts/prototypes/evm/ZetaConnectorNew.sol | 49 + contracts/prototypes/test/GatewayEVM.t.sol | 9 +- .../prototypes/test/GatewayEVMZEVM.t.sol | 11 +- package.json | 2 +- .../evm/gatewayevm.sol/gatewayevm.go | 111 ++- .../gatewayevmupgradetest.go | 841 ++++++++++++------ .../zetaconnectornew.sol/zetaconnectornew.go | 598 +++++++++++++ .../test/gatewayevm.t.sol/gatewayevmtest.go | 2 +- .../gatewayevmzevmtest.go | 2 +- test/prototypes/GatewayEVM.spec.ts | 14 +- test/prototypes/GatewayEVMUniswap.spec.ts | 9 +- test/prototypes/GatewayEVMUpgrade.spec.ts | 6 +- test/prototypes/GatewayIntegration.spec.ts | 6 +- .../contracts/prototypes/evm/GatewayEVM.ts | 78 +- .../prototypes/evm/GatewayEVMUpgradeTest.ts | 459 +++++++--- .../prototypes/evm/ZetaConnectorNew.ts | 237 +++++ .../contracts/prototypes/evm/index.ts | 1 + .../evm/GatewayEVMUpgradeTest__factory.ts | 278 ++++-- .../prototypes/evm/GatewayEVM__factory.ts | 46 +- .../evm/ZetaConnectorNew__factory.ts | 203 +++++ .../contracts/prototypes/evm/index.ts | 1 + .../GatewayEVMTest__factory.ts | 2 +- .../GatewayEVMZEVMTest__factory.ts | 2 +- typechain-types/hardhat.d.ts | 9 + typechain-types/index.ts | 2 + 27 files changed, 2617 insertions(+), 494 deletions(-) create mode 100644 contracts/prototypes/evm/ZetaConnectorNew.sol create mode 100644 pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go create mode 100644 typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 78ca2a49..40225252 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -15,16 +15,19 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate address public custody; address public tssAddress; + address public zetaConnector; + address public zetaAsset; constructor() {} - function initialize(address _tssAddress) public initializer { + function initialize(address _tssAddress, address _zetaAsset) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); if (_tssAddress == address(0)) revert ZeroAddress(); tssAddress = _tssAddress; + zetaAsset = _zetaAsset; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -69,10 +72,14 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Reset approval if(!resetApproval(token, to)) revert ApprovalFailed(); - // Transfer any remaining tokens back to the custody contract + // Transfer any remaining tokens back to the custody/connector contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).safeTransfer(address(custody), remainingBalance); + address destination = address(custody); + if (token == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(token).safeTransfer(address(destination), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -93,7 +100,12 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Deposit ERC20 tokens to custody function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); + + address destination = address(custody); + if (asset == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); emit Deposit(msg.sender, receiver, amount, asset, ""); } @@ -111,7 +123,12 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Deposit ERC20 tokens to custody and call an omnichain smart contract function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).safeTransferFrom(msg.sender, address(custody), amount); + + address destination = address(custody); + if (asset == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); emit Deposit(msg.sender, receiver, amount, asset, payload); } @@ -126,6 +143,11 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate custody = _custody; } + function setConnector(address _zetaConnector) external { + if (zetaConnector != address(0)) revert CustodyInitialized(); + zetaConnector = _zetaConnector; + } + function resetApproval(address token, address to) private returns (bool) { return IERC20(token).approve(to, 0); } diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index 00d3342f..820bc8e3 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -6,40 +6,31 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; - +import "./interfaces.sol"; // NOTE: Purpose of this contract is to test upgrade process, the only difference should be name of Executed event // The Gateway contract is the endpoint to call smart contracts on external chains // The contract doesn't hold any funds and should never have active allowances -contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGatewayEVMErrors, IGatewayEVMEvents { using SafeERC20 for IERC20; - error ExecutionFailed(); - error SendFailed(); - error InsufficientETHAmount(); - error ZeroAddress(); - error ApprovalFailed(); - address public custody; address public tssAddress; + address public zetaConnector; + address public zetaAsset; event ExecutedV2(address indexed destination, uint256 value, bytes data); - event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data); - event SendERC20(bytes recipient, address indexed asset, uint256 amount); - event Send(bytes recipient, uint256 amount); - /// @custom:oz-upgrades-unsafe-allow constructor - constructor() { - _disableInitializers(); - } + constructor() {} - function initialize(address _tssAddress) public initializer { + function initialize(address _tssAddress, address _zetaAsset) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); if (_tssAddress == address(0)) revert ZeroAddress(); - + tssAddress = _tssAddress; + zetaAsset = _zetaAsset; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -72,21 +63,26 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade address to, uint256 amount, bytes calldata data - ) external returns (bytes memory) { + ) public returns (bytes memory) { + if (amount == 0) revert InsufficientETHAmount(); // Approve the target contract to spend the tokens - if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!resetApproval(token, to)) revert ApprovalFailed(); if(!IERC20(token).approve(to, amount)) revert ApprovalFailed(); // Execute the call on the target contract bytes memory result = _execute(to, data); // Reset approval - if(!IERC20(token).approve(to, 0)) revert ApprovalFailed(); + if(!resetApproval(token, to)) revert ApprovalFailed(); - // Transfer any remaining tokens back to the custody contract + // Transfer any remaining tokens back to the custody/connector contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).safeTransfer(address(custody), remainingBalance); + address destination = address(custody); + if (token == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(token).safeTransfer(address(destination), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); @@ -94,25 +90,68 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade return result; } - // Transfer specified token amount to ERC20Custody and emits event - function sendERC20(bytes calldata recipient, address token, uint256 amount) external { - IERC20(token).safeTransferFrom(msg.sender, address(custody), amount); + // Deposit ETH to tss + function deposit(address receiver) external payable { + if (msg.value == 0) revert InsufficientETHAmount(); + (bool deposited, ) = tssAddress.call{value: msg.value}(""); - emit SendERC20(recipient, token, amount); + if (deposited == false) revert DepositFailed(); + + emit Deposit(msg.sender, receiver, msg.value, address(0), ""); } - // Transfer specified ETH amount to TSS address and emits event - function send(bytes calldata recipient, uint256 amount) external payable { + // Deposit ERC20 tokens to custody + function deposit(address receiver, uint256 amount, address asset) external { + if (amount == 0) revert InsufficientERC20Amount(); + + address destination = address(custody); + if (asset == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); + + emit Deposit(msg.sender, receiver, amount, asset, ""); + } + + // Deposit ETH to tss and call an omnichain smart contract + function depositAndCall(address receiver, bytes calldata payload) external payable { if (msg.value == 0) revert InsufficientETHAmount(); + (bool deposited, ) = tssAddress.call{value: msg.value}(""); - (bool sent, ) = tssAddress.call{value: msg.value}(""); + if (deposited == false) revert DepositFailed(); + + emit Deposit(msg.sender, receiver, msg.value, address(0), payload); + } + + // Deposit ERC20 tokens to custody and call an omnichain smart contract + function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { + if (amount == 0) revert InsufficientERC20Amount(); + + address destination = address(custody); + if (asset == zetaAsset) { + destination = address(zetaConnector); + } + IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); - if (sent == false) revert SendFailed(); + emit Deposit(msg.sender, receiver, amount, asset, payload); + } - emit Send(recipient, msg.value); + // Call an omnichain smart contract without asset transfer + function call(address receiver, bytes calldata payload) external { + emit Call(msg.sender, receiver, payload); } function setCustody(address _custody) external { + if (custody != address(0)) revert CustodyInitialized(); custody = _custody; } + + function setConnector(address _zetaConnector) external { + if (zetaConnector != address(0)) revert CustodyInitialized(); + zetaConnector = _zetaConnector; + } + + function resetApproval(address token, address to) private returns (bool) { + return IERC20(token).approve(to, 0); + } } diff --git a/contracts/prototypes/evm/ZetaConnectorNew.sol b/contracts/prototypes/evm/ZetaConnectorNew.sol new file mode 100644 index 00000000..c10d01fc --- /dev/null +++ b/contracts/prototypes/evm/ZetaConnectorNew.sol @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "./interfaces.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; + +contract ZetaConnectorNew is ReentrancyGuard{ + using SafeERC20 for IERC20; + error ZeroAddress(); + + IGatewayEVM public gateway; + IERC20 public zeta; + + event Withdraw(address indexed to, uint256 amount); + event WithdrawAndCall(address indexed to, uint256 amount, bytes data); + + constructor(address _gateway, address _zeta) { + if (_gateway == address(0) || _zeta == address(0)) { + revert ZeroAddress(); + } + gateway = IGatewayEVM(_gateway); + zeta = IERC20(_zeta); + } + + // Withdraw is called by TSS address, it directly transfers zeta to the destination address without contract call + // TODO: Finalize access control + // https://github.com/zeta-chain/protocol-contracts/issues/204 + function withdraw(address to, uint256 amount) external nonReentrant { + zeta.safeTransfer(to, amount); + + emit Withdraw(to, amount); + } + + // WithdrawAndCall is called by TSS address, it transfers zeta and call a contract + // For this, it passes through the Gateway contract, it transfers zeta to the Gateway contract and then calls the contract + // TODO: Finalize access control + // https://github.com/zeta-chain/protocol-contracts/issues/204 + function withdrawAndCall(address to, uint256 amount, bytes calldata data) public nonReentrant { + // Transfer zeta to the Gateway contract + zeta.safeTransfer(address(gateway), amount); + + // Forward the call to the Gateway contract + gateway.executeWithERC20(address(zeta), to, amount, data); + + emit WithdrawAndCall(to, amount, data); + } +} \ No newline at end of file diff --git a/contracts/prototypes/test/GatewayEVM.t.sol b/contracts/prototypes/test/GatewayEVM.t.sol index 4391da90..559a10ba 100644 --- a/contracts/prototypes/test/GatewayEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVM.t.sol @@ -7,6 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -18,7 +19,9 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; + ZetaConnectorNew zetaConnector; TestERC20 token; + TestERC20 zeta; address owner; address destination; address tssAddress; @@ -29,11 +32,15 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver tssAddress = address(0x5678); token = new TestERC20("test", "TTK"); + zeta = new TestERC20("zeta", "ZETA"); + gateway = new GatewayEVM(); custody = new ERC20CustodyNew(address(gateway)); + zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); - gateway.initialize(tssAddress); + gateway.initialize(tssAddress, address(zeta)); gateway.setCustody(address(custody)); + gateway.setConnector(address(zetaConnector)); // Mint initial supply to the owner token.mint(owner, 1000000); diff --git a/contracts/prototypes/test/GatewayEVMZEVM.t.sol b/contracts/prototypes/test/GatewayEVMZEVM.t.sol index 731be2df..d22f46d0 100644 --- a/contracts/prototypes/test/GatewayEVMZEVM.t.sol +++ b/contracts/prototypes/test/GatewayEVMZEVM.t.sol @@ -7,6 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; @@ -25,6 +26,8 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate using SafeERC20 for IERC20; GatewayEVM gatewayEVM; + ZetaConnectorNew zetaConnector; + TestERC20 zeta; ERC20CustodyNew custody; TestERC20 token; ReceiverEVM receiverEVM; @@ -47,11 +50,17 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate ownerZEVM = address(0x4321); token = new TestERC20("test", "TTK"); + zeta = new TestERC20("zeta", "ZETA"); + gatewayEVM = new GatewayEVM(); custody = new ERC20CustodyNew(address(gatewayEVM)); + zetaConnector = new ZetaConnectorNew(address(gatewayEVM), address(zeta)); + + gatewayEVM.initialize(tssAddress, address(zeta)); + custody = new ERC20CustodyNew(address(gatewayEVM)); - gatewayEVM.initialize(tssAddress); gatewayEVM.setCustody(address(custody)); + gatewayEVM.setConnector(address(zetaConnector)); // Mint initial supply to the ownerEVM token.mint(ownerEVM, 1000000); diff --git a/package.json b/package.json index 06e845db..26012fa4 100644 --- a/package.json +++ b/package.json @@ -89,8 +89,8 @@ "localnet": "concurrently --names \"NODE,WORKER\" --prefix-colors \"blue.bold,green.bold\" \"npx hardhat node\" \"wait-on tcp:8545 && yarn worker\"", "prepublishOnly": "yarn build", "test": "npx hardhat test", - "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "test:forge": "forge test -vvv", + "test:prototypes": "yarn compile && npx hardhat test test/prototypes/*", "tsc:watch": "npx tsc --watch", "worker": "npx hardhat run scripts/worker.ts --network localhost" }, diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index db197e19..2d8e9ef4 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -31,8 +31,8 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaAsset\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. @@ -326,6 +326,68 @@ func (_GatewayEVM *GatewayEVMCallerSession) TssAddress() (common.Address, error) return _GatewayEVM.Contract.TssAddress(&_GatewayEVM.CallOpts) } +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) ZetaAsset(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "zetaAsset") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVM *GatewayEVMSession) ZetaAsset() (common.Address, error) { + return _GatewayEVM.Contract.ZetaAsset(&_GatewayEVM.CallOpts) +} + +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) ZetaAsset() (common.Address, error) { + return _GatewayEVM.Contract.ZetaAsset(&_GatewayEVM.CallOpts) +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVM.contract.Call(opts, &out, "zetaConnector") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMSession) ZetaConnector() (common.Address, error) { + return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) ZetaConnector() (common.Address, error) { + return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) +} + // Call is a paid mutator transaction binding the contract method 0x1b8b921d. // // Solidity: function call(address receiver, bytes payload) returns() @@ -473,25 +535,25 @@ func (_GatewayEVM *GatewayEVMTransactorSession) ExecuteWithERC20(token common.Ad return _GatewayEVM.Contract.ExecuteWithERC20(&_GatewayEVM.TransactOpts, token, to, amount, data) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress, _zetaAsset) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaAsset) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaAsset) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. @@ -515,6 +577,27 @@ func (_GatewayEVM *GatewayEVMTransactorSession) RenounceOwnership() (*types.Tran return _GatewayEVM.Contract.RenounceOwnership(&_GatewayEVM.TransactOpts) } +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. +// +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVM *GatewayEVMTransactor) SetConnector(opts *bind.TransactOpts, _zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "setConnector", _zetaConnector) +} + +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. +// +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVM *GatewayEVMSession) SetConnector(_zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.SetConnector(&_GatewayEVM.TransactOpts, _zetaConnector) +} + +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. +// +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) SetConnector(_zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.SetConnector(&_GatewayEVM.TransactOpts, _zetaConnector) +} + // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. // // Solidity: function setCustody(address _custody) returns() diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index bc451ccc..e3dff1ba 100644 --- a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -31,8 +31,8 @@ var ( // GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SendFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Send\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"SendERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"send\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"recipient\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"sendERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaAsset\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. @@ -326,6 +326,173 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) TssAddress() ( return _GatewayEVMUpgradeTest.Contract.TssAddress(&_GatewayEVMUpgradeTest.CallOpts) } +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaAsset(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaAsset") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaAsset() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaAsset(&_GatewayEVMUpgradeTest.CallOpts) +} + +// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// +// Solidity: function zetaAsset() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaAsset() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaAsset(&_GatewayEVMUpgradeTest.CallOpts) +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaConnector") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaConnector() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) +} + +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaConnector() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Call(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "call", receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Call(&_GatewayEVMUpgradeTest.TransactOpts, receiver, payload) +} + +// Call is a paid mutator transaction binding the contract method 0x1b8b921d. +// +// Solidity: function call(address receiver, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Call(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Call(&_GatewayEVMUpgradeTest.TransactOpts, receiver, payload) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Deposit(opts *bind.TransactOpts, receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "deposit", receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Deposit(&_GatewayEVMUpgradeTest.TransactOpts, receiver) +} + +// Deposit is a paid mutator transaction binding the contract method 0xf340fa01. +// +// Solidity: function deposit(address receiver) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Deposit(receiver common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Deposit(&_GatewayEVMUpgradeTest.TransactOpts, receiver) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Deposit0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "deposit0", receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Deposit0(&_GatewayEVMUpgradeTest.TransactOpts, receiver, amount, asset) +} + +// Deposit0 is a paid mutator transaction binding the contract method 0xf45346dc. +// +// Solidity: function deposit(address receiver, uint256 amount, address asset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Deposit0(receiver common.Address, amount *big.Int, asset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Deposit0(&_GatewayEVMUpgradeTest.TransactOpts, receiver, amount, asset) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) DepositAndCall(opts *bind.TransactOpts, receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "depositAndCall", receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.DepositAndCall(&_GatewayEVMUpgradeTest.TransactOpts, receiver, payload) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x29c59b5d. +// +// Solidity: function depositAndCall(address receiver, bytes payload) payable returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) DepositAndCall(receiver common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.DepositAndCall(&_GatewayEVMUpgradeTest.TransactOpts, receiver, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) DepositAndCall0(opts *bind.TransactOpts, receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "depositAndCall0", receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.DepositAndCall0(&_GatewayEVMUpgradeTest.TransactOpts, receiver, amount, asset, payload) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0x8c6f037f. +// +// Solidity: function depositAndCall(address receiver, uint256 amount, address asset, bytes payload) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) DepositAndCall0(receiver common.Address, amount *big.Int, asset common.Address, payload []byte) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.DepositAndCall0(&_GatewayEVMUpgradeTest.TransactOpts, receiver, amount, asset, payload) +} + // Execute is a paid mutator transaction binding the contract method 0x1cff79cd. // // Solidity: function execute(address destination, bytes data) payable returns(bytes) @@ -368,25 +535,25 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) ExecuteWit return _GatewayEVMUpgradeTest.Contract.ExecuteWithERC20(&_GatewayEVMUpgradeTest.TransactOpts, token, to, amount, data) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress, _zetaAsset) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaAsset) } -// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. +// Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress) +// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaAsset) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. @@ -410,46 +577,25 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) RenounceOw return _GatewayEVMUpgradeTest.Contract.RenounceOwnership(&_GatewayEVMUpgradeTest.TransactOpts) } -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Send(opts *bind.TransactOpts, recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.contract.Transact(opts, "send", recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Send(&_GatewayEVMUpgradeTest.TransactOpts, recipient, amount) -} - -// Send is a paid mutator transaction binding the contract method 0x9372c4ab. -// -// Solidity: function send(bytes recipient, uint256 amount) payable returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Send(recipient []byte, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Send(&_GatewayEVMUpgradeTest.TransactOpts, recipient, amount) -} - -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. // -// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) SendERC20(opts *bind.TransactOpts, recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.contract.Transact(opts, "sendERC20", recipient, token, amount) +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) SetConnector(opts *bind.TransactOpts, _zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "setConnector", _zetaConnector) } -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. // -// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.SendERC20(&_GatewayEVMUpgradeTest.TransactOpts, recipient, token, amount) +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) SetConnector(_zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SetConnector(&_GatewayEVMUpgradeTest.TransactOpts, _zetaConnector) } -// SendERC20 is a paid mutator transaction binding the contract method 0xcb0271ed. +// SetConnector is a paid mutator transaction binding the contract method 0x10188aef. // -// Solidity: function sendERC20(bytes recipient, address token, uint256 amount) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) SendERC20(recipient []byte, token common.Address, amount *big.Int) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.SendERC20(&_GatewayEVMUpgradeTest.TransactOpts, recipient, token, amount) +// Solidity: function setConnector(address _zetaConnector) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) SetConnector(_zetaConnector common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.SetConnector(&_GatewayEVMUpgradeTest.TransactOpts, _zetaConnector) } // SetCustody is a paid mutator transaction binding the contract method 0xae7a3a6f. @@ -815,9 +961,9 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseBeaconUpgraded return event, nil } -// GatewayEVMUpgradeTestExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestExecutedV2Iterator struct { - Event *GatewayEVMUpgradeTestExecutedV2 // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestCallIterator is returned from FilterCall and is used to iterate over the raw logs and unpacked data for Call events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestCallIterator struct { + Event *GatewayEVMUpgradeTestCall // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -831,7 +977,7 @@ type GatewayEVMUpgradeTestExecutedV2Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestCallIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -840,7 +986,7 @@ func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestExecutedV2) + it.Event = new(GatewayEVMUpgradeTestCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -855,7 +1001,7 @@ func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestExecutedV2) + it.Event = new(GatewayEVMUpgradeTestCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -871,53 +1017,61 @@ func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Error() error { +func (it *GatewayEVMUpgradeTestCallIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Close() error { +func (it *GatewayEVMUpgradeTestCallIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestExecutedV2 struct { - Destination common.Address - Value *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestCall represents a Call event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestCall struct { + Sender common.Address + Receiver common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos } -// FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// FilterCall is a free log retrieval operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMUpgradeTestExecutedV2Iterator, error) { +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterCall(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMUpgradeTestCallIterator, error) { - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Call", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayEVMUpgradeTestExecutedV2Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil + return &GatewayEVMUpgradeTestCallIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Call", logs: logs, sub: sub}, nil } -// WatchExecutedV2 is a free log subscription operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// WatchCall is a free log subscription operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchCall(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestCall, sender []common.Address, receiver []common.Address) (event.Subscription, error) { - var destinationRule []interface{} - for _, destinationItem := range destination { - destinationRule = append(destinationRule, destinationItem) + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) + } + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Call", senderRule, receiverRule) if err != nil { return nil, err } @@ -927,8 +1081,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedV2(opt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestExecutedV2) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + event := new(GatewayEVMUpgradeTestCall) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Call", log); err != nil { return err } event.Raw = log @@ -949,21 +1103,21 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedV2(opt }), nil } -// ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// ParseCall is a log parse operation binding the contract event 0x2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde3. // -// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedV2(log types.Log) (*GatewayEVMUpgradeTestExecutedV2, error) { - event := new(GatewayEVMUpgradeTestExecutedV2) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { +// Solidity: event Call(address indexed sender, address indexed receiver, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseCall(log types.Log) (*GatewayEVMUpgradeTestCall, error) { + event := new(GatewayEVMUpgradeTestCall) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Call", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayEVMUpgradeTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestExecutedWithERC20Iterator struct { - Event *GatewayEVMUpgradeTestExecutedWithERC20 // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestDepositIterator is returned from FilterDeposit and is used to iterate over the raw logs and unpacked data for Deposit events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestDepositIterator struct { + Event *GatewayEVMUpgradeTestDeposit // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -977,7 +1131,7 @@ type GatewayEVMUpgradeTestExecutedWithERC20Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestDepositIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -986,7 +1140,7 @@ func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + it.Event = new(GatewayEVMUpgradeTestDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1001,7 +1155,7 @@ func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + it.Event = new(GatewayEVMUpgradeTestDeposit) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1017,62 +1171,63 @@ func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Error() error { +func (it *GatewayEVMUpgradeTestDepositIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Close() error { +func (it *GatewayEVMUpgradeTestDepositIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestExecutedWithERC20 struct { - Token common.Address - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestDeposit represents a Deposit event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestDeposit struct { + Sender common.Address + Receiver common.Address + Amount *big.Int + Asset common.Address + Payload []byte + Raw types.Log // Blockchain specific contextual infos } -// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// FilterDeposit is a free log retrieval operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMUpgradeTestExecutedWithERC20Iterator, error) { +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterDeposit(opts *bind.FilterOpts, sender []common.Address, receiver []common.Address) (*GatewayEVMUpgradeTestDepositIterator, error) { - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } - return &GatewayEVMUpgradeTestExecutedWithERC20Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil + return &GatewayEVMUpgradeTestDepositIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Deposit", logs: logs, sub: sub}, nil } -// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// WatchDeposit is a free log subscription operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchDeposit(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestDeposit, sender []common.Address, receiver []common.Address) (event.Subscription, error) { - var tokenRule []interface{} - for _, tokenItem := range token { - tokenRule = append(tokenRule, tokenItem) + var senderRule []interface{} + for _, senderItem := range sender { + senderRule = append(senderRule, senderItem) } - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) + var receiverRule []interface{} + for _, receiverItem := range receiver { + receiverRule = append(receiverRule, receiverItem) } - logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Deposit", senderRule, receiverRule) if err != nil { return nil, err } @@ -1082,8 +1237,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedWithER select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestExecutedWithERC20) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { + event := new(GatewayEVMUpgradeTestDeposit) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Deposit", log); err != nil { return err } event.Raw = log @@ -1104,21 +1259,21 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedWithER }), nil } -// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// ParseDeposit is a log parse operation binding the contract event 0x2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4. // -// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMUpgradeTestExecutedWithERC20, error) { - event := new(GatewayEVMUpgradeTestExecutedWithERC20) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { +// Solidity: event Deposit(address indexed sender, address indexed receiver, uint256 amount, address asset, bytes payload) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseDeposit(log types.Log) (*GatewayEVMUpgradeTestDeposit, error) { + event := new(GatewayEVMUpgradeTestDeposit) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Deposit", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayEVMUpgradeTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestInitializedIterator struct { - Event *GatewayEVMUpgradeTestInitialized // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestExecutedIterator is returned from FilterExecuted and is used to iterate over the raw logs and unpacked data for Executed events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedIterator struct { + Event *GatewayEVMUpgradeTestExecuted // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1132,7 +1287,7 @@ type GatewayEVMUpgradeTestInitializedIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { +func (it *GatewayEVMUpgradeTestExecutedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1141,7 +1296,7 @@ func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestInitialized) + it.Event = new(GatewayEVMUpgradeTestExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1156,7 +1311,7 @@ func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestInitialized) + it.Event = new(GatewayEVMUpgradeTestExecuted) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1172,41 +1327,53 @@ func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestInitializedIterator) Error() error { +func (it *GatewayEVMUpgradeTestExecutedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestInitializedIterator) Close() error { +func (it *GatewayEVMUpgradeTestExecutedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestInitialized represents a Initialized event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestInitialized struct { - Version uint8 - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestExecuted represents a Executed event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecuted struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos } -// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// FilterExecuted is a free log retrieval operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestInitializedIterator, error) { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecuted(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMUpgradeTestExecutedIterator, error) { - logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Initialized") + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Executed", destinationRule) if err != nil { return nil, err } - return &GatewayEVMUpgradeTestInitializedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil + return &GatewayEVMUpgradeTestExecutedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Executed", logs: logs, sub: sub}, nil } -// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// WatchExecuted is a free log subscription operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestInitialized) (event.Subscription, error) { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecuted(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecuted, destination []common.Address) (event.Subscription, error) { - logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Initialized") + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Executed", destinationRule) if err != nil { return nil, err } @@ -1216,8 +1383,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestInitialized) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { + event := new(GatewayEVMUpgradeTestExecuted) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Executed", log); err != nil { return err } event.Raw = log @@ -1238,21 +1405,21 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(op }), nil } -// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// ParseExecuted is a log parse operation binding the contract event 0xcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f. // -// Solidity: event Initialized(uint8 version) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseInitialized(log types.Log) (*GatewayEVMUpgradeTestInitialized, error) { - event := new(GatewayEVMUpgradeTestInitialized) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { +// Solidity: event Executed(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecuted(log types.Log) (*GatewayEVMUpgradeTestExecuted, error) { + event := new(GatewayEVMUpgradeTestExecuted) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Executed", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayEVMUpgradeTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestOwnershipTransferredIterator struct { - Event *GatewayEVMUpgradeTestOwnershipTransferred // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestExecutedV2Iterator is returned from FilterExecutedV2 and is used to iterate over the raw logs and unpacked data for ExecutedV2 events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedV2Iterator struct { + Event *GatewayEVMUpgradeTestExecutedV2 // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1266,7 +1433,7 @@ type GatewayEVMUpgradeTestOwnershipTransferredIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1275,7 +1442,7 @@ func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) + it.Event = new(GatewayEVMUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1290,7 +1457,7 @@ func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) + it.Event = new(GatewayEVMUpgradeTestExecutedV2) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1306,60 +1473,208 @@ func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Error() error { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Close() error { +func (it *GatewayEVMUpgradeTestExecutedV2Iterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestOwnershipTransferred struct { - PreviousOwner common.Address - NewOwner common.Address - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestExecutedV2 represents a ExecutedV2 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedV2 struct { + Destination common.Address + Value *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos } -// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// FilterExecutedV2 is a free log retrieval operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. // -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMUpgradeTestOwnershipTransferredIterator, error) { +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedV2(opts *bind.FilterOpts, destination []common.Address) (*GatewayEVMUpgradeTestExecutedV2Iterator, error) { - var previousOwnerRule []interface{} - for _, previousOwnerItem := range previousOwner { - previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedV2", destinationRule) + if err != nil { + return nil, err } + return &GatewayEVMUpgradeTestExecutedV2Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedV2", logs: logs, sub: sub}, nil +} - logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) +// WatchExecutedV2 is a free log subscription operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. +// +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedV2(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedV2, destination []common.Address) (event.Subscription, error) { + + var destinationRule []interface{} + for _, destinationItem := range destination { + destinationRule = append(destinationRule, destinationItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedV2", destinationRule) if err != nil { return nil, err } - return &GatewayEVMUpgradeTestOwnershipTransferredIterator{contract: _GatewayEVMUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(GatewayEVMUpgradeTestExecutedV2) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", 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 } -// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// ParseExecutedV2 is a log parse operation binding the contract event 0x373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e8546. // -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { +// Solidity: event ExecutedV2(address indexed destination, uint256 value, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedV2(log types.Log) (*GatewayEVMUpgradeTestExecutedV2, error) { + event := new(GatewayEVMUpgradeTestExecutedV2) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedV2", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} - var previousOwnerRule []interface{} - for _, previousOwnerItem := range previousOwner { - previousOwnerRule = append(previousOwnerRule, previousOwnerItem) +// GatewayEVMUpgradeTestExecutedWithERC20Iterator is returned from FilterExecutedWithERC20 and is used to iterate over the raw logs and unpacked data for ExecutedWithERC20 events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedWithERC20Iterator struct { + Event *GatewayEVMUpgradeTestExecutedWithERC20 // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false } - var newOwnerRule []interface{} - for _, newOwnerItem := range newOwner { - newOwnerRule = append(newOwnerRule, newOwnerItem) + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true - logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *GatewayEVMUpgradeTestExecutedWithERC20Iterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// GatewayEVMUpgradeTestExecutedWithERC20 represents a ExecutedWithERC20 event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestExecutedWithERC20 struct { + Token common.Address + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterExecutedWithERC20 is a free log retrieval operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterExecutedWithERC20(opts *bind.FilterOpts, token []common.Address, to []common.Address) (*GatewayEVMUpgradeTestExecutedWithERC20Iterator, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "ExecutedWithERC20", tokenRule, toRule) + if err != nil { + return nil, err + } + return &GatewayEVMUpgradeTestExecutedWithERC20Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "ExecutedWithERC20", logs: logs, sub: sub}, nil +} + +// WatchExecutedWithERC20 is a free log subscription operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. +// +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchExecutedWithERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestExecutedWithERC20, token []common.Address, to []common.Address) (event.Subscription, error) { + + var tokenRule []interface{} + for _, tokenItem := range token { + tokenRule = append(tokenRule, tokenItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "ExecutedWithERC20", tokenRule, toRule) if err != nil { return nil, err } @@ -1369,8 +1684,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchOwnershipTrans select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestOwnershipTransferred) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + event := new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return err } event.Raw = log @@ -1391,21 +1706,21 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchOwnershipTrans }), nil } -// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// ParseExecutedWithERC20 is a log parse operation binding the contract event 0x29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382. // -// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMUpgradeTestOwnershipTransferred, error) { - event := new(GatewayEVMUpgradeTestOwnershipTransferred) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { +// Solidity: event ExecutedWithERC20(address indexed token, address indexed to, uint256 amount, bytes data) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseExecutedWithERC20(log types.Log) (*GatewayEVMUpgradeTestExecutedWithERC20, error) { + event := new(GatewayEVMUpgradeTestExecutedWithERC20) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "ExecutedWithERC20", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayEVMUpgradeTestSendIterator is returned from FilterSend and is used to iterate over the raw logs and unpacked data for Send events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestSendIterator struct { - Event *GatewayEVMUpgradeTestSend // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestInitializedIterator struct { + Event *GatewayEVMUpgradeTestInitialized // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1419,7 +1734,7 @@ type GatewayEVMUpgradeTestSendIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { +func (it *GatewayEVMUpgradeTestInitializedIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1428,7 +1743,7 @@ func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestSend) + it.Event = new(GatewayEVMUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1443,7 +1758,7 @@ func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestSend) + it.Event = new(GatewayEVMUpgradeTestInitialized) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1459,42 +1774,41 @@ func (it *GatewayEVMUpgradeTestSendIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestSendIterator) Error() error { +func (it *GatewayEVMUpgradeTestInitializedIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestSendIterator) Close() error { +func (it *GatewayEVMUpgradeTestInitializedIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestSend represents a Send event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestSend struct { - Recipient []byte - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestInitialized represents a Initialized event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos } -// FilterSend is a free log retrieval operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(bytes recipient, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterSend(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestSendIterator, error) { +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterInitialized(opts *bind.FilterOpts) (*GatewayEVMUpgradeTestInitializedIterator, error) { - logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Send") + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "Initialized") if err != nil { return nil, err } - return &GatewayEVMUpgradeTestSendIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Send", logs: logs, sub: sub}, nil + return &GatewayEVMUpgradeTestInitializedIterator{contract: _GatewayEVMUpgradeTest.contract, event: "Initialized", logs: logs, sub: sub}, nil } -// WatchSend is a free log subscription operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(bytes recipient, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSend(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestSend) (event.Subscription, error) { +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestInitialized) (event.Subscription, error) { - logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Send") + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "Initialized") if err != nil { return nil, err } @@ -1504,8 +1818,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSend(opts *bin select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestSend) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { + event := new(GatewayEVMUpgradeTestInitialized) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { return err } event.Raw = log @@ -1526,21 +1840,21 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSend(opts *bin }), nil } -// ParseSend is a log parse operation binding the contract event 0xa93afc57f3be4641cf20c7165d11856f3b46dd376108e5fffb06f73f2b2a6d58. +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. // -// Solidity: event Send(bytes recipient, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseSend(log types.Log) (*GatewayEVMUpgradeTestSend, error) { - event := new(GatewayEVMUpgradeTestSend) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Send", log); err != nil { +// Solidity: event Initialized(uint8 version) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseInitialized(log types.Log) (*GatewayEVMUpgradeTestInitialized, error) { + event := new(GatewayEVMUpgradeTestInitialized) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "Initialized", log); err != nil { return nil, err } event.Raw = log return event, nil } -// GatewayEVMUpgradeTestSendERC20Iterator is returned from FilterSendERC20 and is used to iterate over the raw logs and unpacked data for SendERC20 events raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestSendERC20Iterator struct { - Event *GatewayEVMUpgradeTestSendERC20 // Event containing the contract specifics and raw log +// GatewayEVMUpgradeTestOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestOwnershipTransferredIterator struct { + Event *GatewayEVMUpgradeTestOwnershipTransferred // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1554,7 +1868,7 @@ type GatewayEVMUpgradeTestSendERC20Iterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1563,7 +1877,7 @@ func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestSendERC20) + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1578,7 +1892,7 @@ func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(GatewayEVMUpgradeTestSendERC20) + it.Event = new(GatewayEVMUpgradeTestOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1594,53 +1908,60 @@ func (it *GatewayEVMUpgradeTestSendERC20Iterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *GatewayEVMUpgradeTestSendERC20Iterator) Error() error { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *GatewayEVMUpgradeTestSendERC20Iterator) Close() error { +func (it *GatewayEVMUpgradeTestOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// GatewayEVMUpgradeTestSendERC20 represents a SendERC20 event raised by the GatewayEVMUpgradeTest contract. -type GatewayEVMUpgradeTestSendERC20 struct { - Recipient []byte - Asset common.Address - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// GatewayEVMUpgradeTestOwnershipTransferred represents a OwnershipTransferred event raised by the GatewayEVMUpgradeTest contract. +type GatewayEVMUpgradeTestOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos } -// FilterSendERC20 is a free log retrieval operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterSendERC20(opts *bind.FilterOpts, asset []common.Address) (*GatewayEVMUpgradeTestSendERC20Iterator, error) { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*GatewayEVMUpgradeTestOwnershipTransferredIterator, error) { - var assetRule []interface{} - for _, assetItem := range asset { - assetRule = append(assetRule, assetItem) + 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 := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &GatewayEVMUpgradeTestSendERC20Iterator{contract: _GatewayEVMUpgradeTest.contract, event: "SendERC20", logs: logs, sub: sub}, nil + return &GatewayEVMUpgradeTestOwnershipTransferredIterator{contract: _GatewayEVMUpgradeTest.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil } -// WatchSendERC20 is a free log subscription operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSendERC20(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestSendERC20, asset []common.Address) (event.Subscription, error) { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *GatewayEVMUpgradeTestOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { - var assetRule []interface{} - for _, assetItem := range asset { - assetRule = append(assetRule, assetItem) + 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 := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "SendERC20", assetRule) + logs, sub, err := _GatewayEVMUpgradeTest.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -1650,8 +1971,8 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSendERC20(opts select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(GatewayEVMUpgradeTestSendERC20) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { + event := new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -1672,12 +1993,12 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) WatchSendERC20(opts }), nil } -// ParseSendERC20 is a log parse operation binding the contract event 0x35fb30ed1b8e81eb91001dad742b13b1491a67c722e8c593a886a18500f7d9af. +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SendERC20(bytes recipient, address indexed asset, uint256 amount) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseSendERC20(log types.Log) (*GatewayEVMUpgradeTestSendERC20, error) { - event := new(GatewayEVMUpgradeTestSendERC20) - if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "SendERC20", log); err != nil { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestFilterer) ParseOwnershipTransferred(log types.Log) (*GatewayEVMUpgradeTestOwnershipTransferred, error) { + event := new(GatewayEVMUpgradeTestOwnershipTransferred) + if err := _GatewayEVMUpgradeTest.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go new file mode 100644 index 00000000..8e02d957 --- /dev/null +++ b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go @@ -0,0 +1,598 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zetaconnectornew + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZetaConnectorNewMetaData contains all meta data concerning the ZetaConnectorNew contract. +var ZetaConnectorNewMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// ZetaConnectorNewABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNewMetaData.ABI instead. +var ZetaConnectorNewABI = ZetaConnectorNewMetaData.ABI + +// ZetaConnectorNewBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZetaConnectorNewMetaData.Bin instead. +var ZetaConnectorNewBin = ZetaConnectorNewMetaData.Bin + +// DeployZetaConnectorNew deploys a new Ethereum contract, binding an instance of ZetaConnectorNew to it. +func DeployZetaConnectorNew(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zeta common.Address) (common.Address, *types.Transaction, *ZetaConnectorNew, error) { + parsed, err := ZetaConnectorNewMetaData.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(ZetaConnectorNewBin), backend, _gateway, _zeta) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ZetaConnectorNew{ZetaConnectorNewCaller: ZetaConnectorNewCaller{contract: contract}, ZetaConnectorNewTransactor: ZetaConnectorNewTransactor{contract: contract}, ZetaConnectorNewFilterer: ZetaConnectorNewFilterer{contract: contract}}, nil +} + +// ZetaConnectorNew is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNew struct { + ZetaConnectorNewCaller // Read-only binding to the contract + ZetaConnectorNewTransactor // Write-only binding to the contract + ZetaConnectorNewFilterer // Log filterer for contract events +} + +// ZetaConnectorNewCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNewCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNewTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNewFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZetaConnectorNewSession struct { + Contract *ZetaConnectorNew // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZetaConnectorNewCallerSession struct { + Contract *ZetaConnectorNewCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZetaConnectorNewTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZetaConnectorNewTransactorSession struct { + Contract *ZetaConnectorNewTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNewRaw struct { + Contract *ZetaConnectorNew // Generic contract binding to access the raw methods on +} + +// ZetaConnectorNewCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNewCallerRaw struct { + Contract *ZetaConnectorNewCaller // Generic read-only contract binding to access the raw methods on +} + +// ZetaConnectorNewTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNewTransactorRaw struct { + Contract *ZetaConnectorNewTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZetaConnectorNew creates a new instance of ZetaConnectorNew, bound to a specific deployed contract. +func NewZetaConnectorNew(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNew, error) { + contract, err := bindZetaConnectorNew(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZetaConnectorNew{ZetaConnectorNewCaller: ZetaConnectorNewCaller{contract: contract}, ZetaConnectorNewTransactor: ZetaConnectorNewTransactor{contract: contract}, ZetaConnectorNewFilterer: ZetaConnectorNewFilterer{contract: contract}}, nil +} + +// NewZetaConnectorNewCaller creates a new read-only instance of ZetaConnectorNew, bound to a specific deployed contract. +func NewZetaConnectorNewCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewCaller, error) { + contract, err := bindZetaConnectorNew(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewCaller{contract: contract}, nil +} + +// NewZetaConnectorNewTransactor creates a new write-only instance of ZetaConnectorNew, bound to a specific deployed contract. +func NewZetaConnectorNewTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewTransactor, error) { + contract, err := bindZetaConnectorNew(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewTransactor{contract: contract}, nil +} + +// NewZetaConnectorNewFilterer creates a new log filterer instance of ZetaConnectorNew, bound to a specific deployed contract. +func NewZetaConnectorNewFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewFilterer, error) { + contract, err := bindZetaConnectorNew(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZetaConnectorNewFilterer{contract: contract}, nil +} + +// bindZetaConnectorNew binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNew(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNewMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNew *ZetaConnectorNewRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNew.Contract.ZetaConnectorNewCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNew *ZetaConnectorNewRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.ZetaConnectorNewTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNew *ZetaConnectorNewRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.ZetaConnectorNewTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNew *ZetaConnectorNewCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNew.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNew *ZetaConnectorNewTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNew *ZetaConnectorNewTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNew.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewSession) Gateway() (common.Address, error) { + return _ZetaConnectorNew.Contract.Gateway(&_ZetaConnectorNew.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNew.Contract.Gateway(&_ZetaConnectorNew.CallOpts) +} + +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// +// Solidity: function zeta() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNew.contract.Call(opts, &out, "zeta") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// +// Solidity: function zeta() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewSession) Zeta() (common.Address, error) { + return _ZetaConnectorNew.Contract.Zeta(&_ZetaConnectorNew.CallOpts) +} + +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// +// Solidity: function zeta() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) Zeta() (common.Address, error) { + return _ZetaConnectorNew.Contract.Zeta(&_ZetaConnectorNew.CallOpts) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. +// +// Solidity: function withdraw(address to, uint256 amount) returns() +func (_ZetaConnectorNew *ZetaConnectorNewTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNew.contract.Transact(opts, "withdraw", to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. +// +// Solidity: function withdraw(address to, uint256 amount) returns() +func (_ZetaConnectorNew *ZetaConnectorNewSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.Withdraw(&_ZetaConnectorNew.TransactOpts, to, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. +// +// Solidity: function withdraw(address to, uint256 amount) returns() +func (_ZetaConnectorNew *ZetaConnectorNewTransactorSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.Withdraw(&_ZetaConnectorNew.TransactOpts, to, amount) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ZetaConnectorNew *ZetaConnectorNewTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ZetaConnectorNew.contract.Transact(opts, "withdrawAndCall", to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ZetaConnectorNew *ZetaConnectorNewSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.WithdrawAndCall(&_ZetaConnectorNew.TransactOpts, to, amount, data) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() +func (_ZetaConnectorNew *ZetaConnectorNewTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { + return _ZetaConnectorNew.Contract.WithdrawAndCall(&_ZetaConnectorNew.TransactOpts, to, amount, data) +} + +// ZetaConnectorNewWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNew contract. +type ZetaConnectorNewWithdrawIterator struct { + Event *ZetaConnectorNewWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewWithdraw represents a Withdraw event raised by the ZetaConnectorNew contract. +type ZetaConnectorNewWithdraw struct { + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewWithdrawIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNew.contract.FilterLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewWithdrawIterator{contract: _ZetaConnectorNew.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewWithdraw, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNew.contract.WatchLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewWithdraw) + if err := _ZetaConnectorNew.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewWithdraw, error) { + event := new(ZetaConnectorNewWithdraw) + if err := _ZetaConnectorNew.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZetaConnectorNewWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNew contract. +type ZetaConnectorNewWithdrawAndCallIterator struct { + Event *ZetaConnectorNewWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNew contract. +type ZetaConnectorNewWithdrawAndCall struct { + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewWithdrawAndCallIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNew.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewWithdrawAndCallIterator{contract: _ZetaConnectorNew.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewWithdrawAndCall, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNew.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewWithdrawAndCall) + if err := _ZetaConnectorNew.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNew *ZetaConnectorNewFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewWithdrawAndCall, error) { + event := new(ZetaConnectorNewWithdrawAndCall) + if err := _ZetaConnectorNew.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go index b7168498..0eb4c3ac 100644 --- a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. var GatewayEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 258118d3..72455345 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. diff --git a/test/prototypes/GatewayEVM.spec.ts b/test/prototypes/GatewayEVM.spec.ts index 8e0b3c77..1258196c 100644 --- a/test/prototypes/GatewayEVM.spec.ts +++ b/test/prototypes/GatewayEVM.spec.ts @@ -2,7 +2,7 @@ import { expect } from "chai"; import { BigNumber, Contract } from "ethers"; import { ethers, upgrades } from "hardhat"; -describe("GatewayEVM inbound", function () { +describe("GatewayEVM execute", function () { let receiver: Contract; let gateway: Contract; let token: Contract; @@ -14,18 +14,22 @@ describe("GatewayEVM inbound", function () { const Receiver = await ethers.getContractFactory("ReceiverEVM"); const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); [owner, destination, tssAddress] = await ethers.getSigners(); // Deploy the contracts + const zeta = await TestERC20.deploy("Zeta", "ZETA"); token = await TestERC20.deploy("Test Token", "TTK"); receiver = await Receiver.deploy(); - gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", kind: "uups", }); custody = await Custody.deploy(gateway.address); + const zetaConnector = await ZetaConnector.deploy(gateway.address, zeta.address); gateway.setCustody(custody.address); + gateway.setConnector(zetaConnector.address); // Mint initial supply to the owner await token.mint(owner.address, ethers.utils.parseEther("1000")); @@ -131,17 +135,21 @@ describe("GatewayEVM inbound", function () { const TestERC20 = await ethers.getContractFactory("TestERC20"); const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); [owner, destination, tssAddress] = await ethers.getSigners(); // Deploy the contracts + const zeta = await TestERC20.deploy("Zeta", "ZETA"); token = await TestERC20.deploy("Test Token", "TTK"); - gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", kind: "uups", }); custody = await Custody.deploy(gateway.address); + const zetaConnector = await ZetaConnector.deploy(gateway.address, zeta.address); gateway.setCustody(custody.address); + gateway.setConnector(zetaConnector.address); // Mint initial supply to the owner await token.mint(owner.address, ethers.utils.parseEther("1000")); diff --git a/test/prototypes/GatewayEVMUniswap.spec.ts b/test/prototypes/GatewayEVMUniswap.spec.ts index c4e392fa..0ba2cbf9 100644 --- a/test/prototypes/GatewayEVMUniswap.spec.ts +++ b/test/prototypes/GatewayEVMUniswap.spec.ts @@ -56,14 +56,19 @@ describe("Uniswap Integration with GatewayEVM", function () { Math.floor(Date.now() / 1000) + 60 * 20 ); - // Deploy Gateway and Custody Contracts + // Deploy contracts const Gateway = await ethers.getContractFactory("GatewayEVM"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address], { + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); + const zeta = await TestERC20.deploy("Zeta", "ZETA"); + gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", kind: "uups", })) as GatewayEVM; custody = (await ERC20CustodyNew.deploy(gateway.address)) as ERC20CustodyNew; + gateway.setCustody(custody.address); + const zetaConnector = await ZetaConnector.deploy(gateway.address, zeta.address); + gateway.setConnector(zetaConnector.address); // Transfer some tokens to the custody contract await tokenA.transfer(custody.address, ethers.utils.parseEther("100")); diff --git a/test/prototypes/GatewayEVMUpgrade.spec.ts b/test/prototypes/GatewayEVMUpgrade.spec.ts index 8e663ea1..f480ffff 100644 --- a/test/prototypes/GatewayEVMUpgrade.spec.ts +++ b/test/prototypes/GatewayEVMUpgrade.spec.ts @@ -14,18 +14,22 @@ describe("GatewayEVM upgrade", function () { const Receiver = await ethers.getContractFactory("ReceiverEVM"); const Gateway = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); [owner, destination, randomSigner, tssAddress] = await ethers.getSigners(); // Deploy the contracts + const zeta = await TestERC20.deploy("Zeta", "ZETA"); token = await TestERC20.deploy("Test Token", "TTK"); receiver = await Receiver.deploy(); - gateway = await upgrades.deployProxy(Gateway, [tssAddress.address], { + gateway = await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", kind: "uups", }); custody = await Custody.deploy(gateway.address); + const zetaConnector = await ZetaConnector.deploy(gateway.address, zeta.address); gateway.setCustody(custody.address); + gateway.setConnector(zetaConnector.address); // Mint initial supply to the owner await token.mint(owner.address, ethers.utils.parseEther("1000")); diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 998c63bc..1fef7d6e 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -32,17 +32,21 @@ describe("GatewayEVM GatewayZEVM integration", function () { const ReceiverEVM = await ethers.getContractFactory("ReceiverEVM"); const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); // Deploy the contracts + const zeta = await TestERC20.deploy("Zeta", "ZETA"); token = await TestERC20.deploy("Test Token", "TTK"); receiverEVM = await ReceiverEVM.deploy(); - gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tssAddress.address], { + gatewayEVM = await upgrades.deployProxy(GatewayEVM, [tssAddress.address, zeta.address], { initializer: "initialize", kind: "uups", }); custody = await Custody.deploy(gatewayEVM.address); + const zetaConnector = await ZetaConnector.deploy(gatewayEVM.address, zeta.address); gatewayEVM.setCustody(custody.address); + gatewayEVM.setConnector(zetaConnector.address); // Mint initial supply to the owner await token.mint(ownerEVM.address, ethers.utils.parseEther("1000")); diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts index 45ca3f7f..5b4d61dc 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -38,15 +38,18 @@ export interface GatewayEVMInterface extends utils.Interface { "depositAndCall(address,uint256,address,bytes)": FunctionFragment; "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; - "initialize(address)": FunctionFragment; + "initialize(address,address)": FunctionFragment; "owner()": FunctionFragment; "proxiableUUID()": FunctionFragment; "renounceOwnership()": FunctionFragment; + "setConnector(address)": FunctionFragment; "setCustody(address)": FunctionFragment; "transferOwnership(address)": FunctionFragment; "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; + "zetaAsset()": FunctionFragment; + "zetaConnector()": FunctionFragment; }; getFunction( @@ -63,11 +66,14 @@ export interface GatewayEVMInterface extends utils.Interface { | "owner" | "proxiableUUID" | "renounceOwnership" + | "setConnector" | "setCustody" | "transferOwnership" | "tssAddress" | "upgradeTo" | "upgradeToAndCall" + | "zetaAsset" + | "zetaConnector" ): FunctionFragment; encodeFunctionData( @@ -115,7 +121,7 @@ export interface GatewayEVMInterface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "initialize", - values: [PromiseOrValue] + values: [PromiseOrValue, PromiseOrValue] ): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData( @@ -126,6 +132,10 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "renounceOwnership", values?: undefined ): string; + encodeFunctionData( + functionFragment: "setConnector", + values: [PromiseOrValue] + ): string; encodeFunctionData( functionFragment: "setCustody", values: [PromiseOrValue] @@ -146,6 +156,11 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; + encodeFunctionData(functionFragment: "zetaAsset", values?: undefined): string; + encodeFunctionData( + functionFragment: "zetaConnector", + values?: undefined + ): string; decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; @@ -180,6 +195,10 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "renounceOwnership", data: BytesLike ): Result; + decodeFunctionResult( + functionFragment: "setConnector", + data: BytesLike + ): Result; decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; decodeFunctionResult( functionFragment: "transferOwnership", @@ -191,6 +210,11 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "zetaAsset", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "zetaConnector", + data: BytesLike + ): Result; events: { "AdminChanged(address,address)": EventFragment; @@ -388,6 +412,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -399,6 +424,11 @@ export interface GatewayEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + setConnector( + _zetaConnector: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -421,6 +451,10 @@ export interface GatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise<[string]>; + + zetaConnector(overrides?: CallOverrides): Promise<[string]>; }; call( @@ -473,6 +507,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -484,6 +519,11 @@ export interface GatewayEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + setConnector( + _zetaConnector: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -507,6 +547,10 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; + callStatic: { call( receiver: PromiseOrValue, @@ -558,6 +602,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -567,6 +612,11 @@ export interface GatewayEVM extends BaseContract { renounceOwnership(overrides?: CallOverrides): Promise; + setConnector( + _zetaConnector: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: CallOverrides @@ -589,6 +639,10 @@ export interface GatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: CallOverrides ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; filters: { @@ -729,6 +783,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -740,6 +795,11 @@ export interface GatewayEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + setConnector( + _zetaConnector: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -762,6 +822,10 @@ export interface GatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -815,6 +879,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -826,6 +891,11 @@ export interface GatewayEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + setConnector( + _zetaConnector: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + setCustody( _custody: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } @@ -848,5 +918,9 @@ export interface GatewayEVM extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts index 27f1c7e1..9cb10767 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts @@ -30,41 +30,82 @@ import type { export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functions: { + "call(address,bytes)": FunctionFragment; "custody()": FunctionFragment; + "deposit(address)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall(address,bytes)": FunctionFragment; + "depositAndCall(address,uint256,address,bytes)": FunctionFragment; "execute(address,bytes)": FunctionFragment; "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; - "initialize(address)": FunctionFragment; + "initialize(address,address)": FunctionFragment; "owner()": FunctionFragment; "proxiableUUID()": FunctionFragment; "renounceOwnership()": FunctionFragment; - "send(bytes,uint256)": FunctionFragment; - "sendERC20(bytes,address,uint256)": FunctionFragment; + "setConnector(address)": FunctionFragment; "setCustody(address)": FunctionFragment; "transferOwnership(address)": FunctionFragment; "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; + "zetaAsset()": FunctionFragment; + "zetaConnector()": FunctionFragment; }; getFunction( nameOrSignatureOrTopic: + | "call" | "custody" + | "deposit(address)" + | "deposit(address,uint256,address)" + | "depositAndCall(address,bytes)" + | "depositAndCall(address,uint256,address,bytes)" | "execute" | "executeWithERC20" | "initialize" | "owner" | "proxiableUUID" | "renounceOwnership" - | "send" - | "sendERC20" + | "setConnector" | "setCustody" | "transferOwnership" | "tssAddress" | "upgradeTo" | "upgradeToAndCall" + | "zetaAsset" + | "zetaConnector" ): FunctionFragment; + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; encodeFunctionData(functionFragment: "custody", values?: undefined): string; + encodeFunctionData( + functionFragment: "deposit(address)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deposit(address,uint256,address)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; encodeFunctionData( functionFragment: "execute", values: [PromiseOrValue, PromiseOrValue] @@ -80,7 +121,7 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "initialize", - values: [PromiseOrValue] + values: [PromiseOrValue, PromiseOrValue] ): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData( @@ -92,16 +133,8 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { values?: undefined ): string; encodeFunctionData( - functionFragment: "send", - values: [PromiseOrValue, PromiseOrValue] - ): string; - encodeFunctionData( - functionFragment: "sendERC20", - values: [ - PromiseOrValue, - PromiseOrValue, - PromiseOrValue - ] + functionFragment: "setConnector", + values: [PromiseOrValue] ): string; encodeFunctionData( functionFragment: "setCustody", @@ -123,8 +156,30 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; + encodeFunctionData(functionFragment: "zetaAsset", values?: undefined): string; + encodeFunctionData( + functionFragment: "zetaConnector", + values?: undefined + ): string; + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "deposit(address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "deposit(address,uint256,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall(address,uint256,address,bytes)", + data: BytesLike + ): Result; decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; decodeFunctionResult( functionFragment: "executeWithERC20", @@ -140,8 +195,10 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "renounceOwnership", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "send", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "sendERC20", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "setConnector", + data: BytesLike + ): Result; decodeFunctionResult(functionFragment: "setCustody", data: BytesLike): Result; decodeFunctionResult( functionFragment: "transferOwnership", @@ -153,27 +210,34 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "zetaAsset", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "zetaConnector", + data: BytesLike + ): Result; events: { "AdminChanged(address,address)": EventFragment; "BeaconUpgraded(address)": EventFragment; + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; "ExecutedV2(address,uint256,bytes)": EventFragment; "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; "Initialized(uint8)": EventFragment; "OwnershipTransferred(address,address)": EventFragment; - "Send(bytes,uint256)": EventFragment; - "SendERC20(bytes,address,uint256)": EventFragment; "Upgraded(address)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; getEvent(nameOrSignatureOrTopic: "BeaconUpgraded"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; getEvent(nameOrSignatureOrTopic: "ExecutedV2"): EventFragment; getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment; getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment; - getEvent(nameOrSignatureOrTopic: "Send"): EventFragment; - getEvent(nameOrSignatureOrTopic: "SendERC20"): EventFragment; getEvent(nameOrSignatureOrTopic: "Upgraded"): EventFragment; } @@ -198,6 +262,41 @@ export type BeaconUpgradedEvent = TypedEvent< export type BeaconUpgradedEventFilter = TypedEventFilter; +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + export interface ExecutedV2EventObject { destination: string; value: BigNumber; @@ -243,26 +342,6 @@ export type OwnershipTransferredEvent = TypedEvent< export type OwnershipTransferredEventFilter = TypedEventFilter; -export interface SendEventObject { - recipient: string; - amount: BigNumber; -} -export type SendEvent = TypedEvent<[string, BigNumber], SendEventObject>; - -export type SendEventFilter = TypedEventFilter; - -export interface SendERC20EventObject { - recipient: string; - asset: string; - amount: BigNumber; -} -export type SendERC20Event = TypedEvent< - [string, string, BigNumber], - SendERC20EventObject ->; - -export type SendERC20EventFilter = TypedEventFilter; - export interface UpgradedEventObject { implementation: string; } @@ -297,8 +376,40 @@ export interface GatewayEVMUpgradeTest extends BaseContract { removeListener: OnEvent; functions: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + custody(overrides?: CallOverrides): Promise<[string]>; + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + execute( destination: PromiseOrValue, data: PromiseOrValue, @@ -315,6 +426,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -326,16 +438,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - token: PromiseOrValue, - amount: PromiseOrValue, + setConnector( + _zetaConnector: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -361,10 +465,46 @@ export interface GatewayEVMUpgradeTest extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise<[string]>; + + zetaConnector(overrides?: CallOverrides): Promise<[string]>; }; + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + custody(overrides?: CallOverrides): Promise; + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + execute( destination: PromiseOrValue, data: PromiseOrValue, @@ -381,6 +521,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -392,16 +533,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - token: PromiseOrValue, - amount: PromiseOrValue, + setConnector( + _zetaConnector: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -428,9 +561,45 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; + callStatic: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + custody(overrides?: CallOverrides): Promise; + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + execute( destination: PromiseOrValue, data: PromiseOrValue, @@ -447,6 +616,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -456,16 +626,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { renounceOwnership(overrides?: CallOverrides): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: CallOverrides - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - token: PromiseOrValue, - amount: PromiseOrValue, + setConnector( + _zetaConnector: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -491,6 +653,10 @@ export interface GatewayEVMUpgradeTest extends BaseContract { data: PromiseOrValue, overrides?: CallOverrides ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; filters: { @@ -510,6 +676,43 @@ export interface GatewayEVMUpgradeTest extends BaseContract { beacon?: PromiseOrValue | null ): BeaconUpgradedEventFilter; + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + "ExecutedV2(address,uint256,bytes)"( destination?: PromiseOrValue | null, value?: null, @@ -546,20 +749,6 @@ export interface GatewayEVMUpgradeTest extends BaseContract { newOwner?: PromiseOrValue | null ): OwnershipTransferredEventFilter; - "Send(bytes,uint256)"(recipient?: null, amount?: null): SendEventFilter; - Send(recipient?: null, amount?: null): SendEventFilter; - - "SendERC20(bytes,address,uint256)"( - recipient?: null, - asset?: PromiseOrValue | null, - amount?: null - ): SendERC20EventFilter; - SendERC20( - recipient?: null, - asset?: PromiseOrValue | null, - amount?: null - ): SendERC20EventFilter; - "Upgraded(address)"( implementation?: PromiseOrValue | null ): UpgradedEventFilter; @@ -569,8 +758,40 @@ export interface GatewayEVMUpgradeTest extends BaseContract { }; estimateGas: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + custody(overrides?: CallOverrides): Promise; + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + execute( destination: PromiseOrValue, data: PromiseOrValue, @@ -587,6 +808,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -598,16 +820,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - token: PromiseOrValue, - amount: PromiseOrValue, + setConnector( + _zetaConnector: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -633,11 +847,47 @@ export interface GatewayEVMUpgradeTest extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; populateTransaction: { + call( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + custody(overrides?: CallOverrides): Promise; + "deposit(address)"( + receiver: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "deposit(address,uint256,address)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,bytes)"( + receiver: PromiseOrValue, + payload: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall(address,uint256,address,bytes)"( + receiver: PromiseOrValue, + amount: PromiseOrValue, + asset: PromiseOrValue, + payload: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + execute( destination: PromiseOrValue, data: PromiseOrValue, @@ -654,6 +904,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, + _zetaAsset: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -665,16 +916,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - send( - recipient: PromiseOrValue, - amount: PromiseOrValue, - overrides?: PayableOverrides & { from?: PromiseOrValue } - ): Promise; - - sendERC20( - recipient: PromiseOrValue, - token: PromiseOrValue, - amount: PromiseOrValue, + setConnector( + _zetaConnector: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -700,5 +943,9 @@ export interface GatewayEVMUpgradeTest extends BaseContract { data: PromiseOrValue, overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; + + zetaAsset(overrides?: CallOverrides): Promise; + + zetaConnector(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts new file mode 100644 index 00000000..812ea2e0 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts @@ -0,0 +1,237 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZetaConnectorNewInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "withdraw(address,uint256)": FunctionFragment; + "withdrawAndCall(address,uint256,bytes)": FunctionFragment; + "zeta()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "gateway" | "withdraw" | "withdrawAndCall" | "zeta" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "zeta", values?: undefined): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; + + events: { + "Withdraw(address,uint256)": EventFragment; + "WithdrawAndCall(address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ZetaConnectorNew extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZetaConnectorNewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zeta(overrides?: CallOverrides): Promise<[string]>; + }; + + gateway(overrides?: CallOverrides): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zeta(overrides?: CallOverrides): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + zeta(overrides?: CallOverrides): Promise; + }; + + filters: { + "Withdraw(address,uint256)"( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,uint256,bytes)"( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zeta(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zeta(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 939b9af8..48438670 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -8,3 +8,4 @@ export type { GatewayEVM } from "./GatewayEVM"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; +export type { ZetaConnectorNew } from "./ZetaConnectorNew"; diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index 3f58fa3f..b9f3437e 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -20,6 +20,16 @@ const _abi = [ name: "ApprovalFailed", type: "error", }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, { inputs: [], name: "ExecutionFailed", @@ -27,12 +37,12 @@ const _abi = [ }, { inputs: [], - name: "InsufficientETHAmount", + name: "InsufficientERC20Amount", type: "error", }, { inputs: [], - name: "SendFailed", + name: "InsufficientETHAmount", type: "error", }, { @@ -72,6 +82,93 @@ const _abi = [ name: "BeaconUpgraded", type: "event", }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, { anonymous: false, inputs: [ @@ -164,70 +261,126 @@ const _abi = [ anonymous: false, inputs: [ { - indexed: false, + indexed: true, + internalType: "address", + name: "implementation", + type: "address", + }, + ], + name: "Upgraded", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "receiver", + type: "address", + }, + { internalType: "bytes", - name: "recipient", + name: "payload", type: "bytes", }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "custody", + outputs: [ { - indexed: false, - internalType: "uint256", - name: "amount", - type: "uint256", + internalType: "address", + name: "", + type: "address", }, ], - name: "Send", - type: "event", + stateMutability: "view", + type: "function", }, { - anonymous: false, inputs: [ { - indexed: false, - internalType: "bytes", - name: "recipient", - type: "bytes", + internalType: "address", + name: "receiver", + type: "address", }, + ], + name: "deposit", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ { - indexed: true, internalType: "address", - name: "asset", + name: "receiver", type: "address", }, { - indexed: false, internalType: "uint256", name: "amount", type: "uint256", }, + { + internalType: "address", + name: "asset", + type: "address", + }, ], - name: "SendERC20", - type: "event", + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", }, { - anonymous: false, inputs: [ { - indexed: true, internalType: "address", - name: "implementation", + name: "receiver", type: "address", }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, ], - name: "Upgraded", - type: "event", + name: "depositAndCall", + outputs: [], + stateMutability: "payable", + type: "function", }, { - inputs: [], - name: "custody", - outputs: [ + inputs: [ { internalType: "address", - name: "", + name: "receiver", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "asset", type: "address", }, + { + internalType: "bytes", + name: "payload", + type: "bytes", + }, ], - stateMutability: "view", + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", type: "function", }, { @@ -295,6 +448,11 @@ const _abi = [ name: "_tssAddress", type: "address", }, + { + internalType: "address", + name: "_zetaAsset", + type: "address", + }, ], name: "initialize", outputs: [], @@ -336,41 +494,13 @@ const _abi = [ }, { inputs: [ - { - internalType: "bytes", - name: "recipient", - type: "bytes", - }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, - ], - name: "send", - outputs: [], - stateMutability: "payable", - type: "function", - }, - { - inputs: [ - { - internalType: "bytes", - name: "recipient", - type: "bytes", - }, { internalType: "address", - name: "token", + name: "_zetaConnector", type: "address", }, - { - internalType: "uint256", - name: "amount", - type: "uint256", - }, ], - name: "sendERC20", + name: "setConnector", outputs: [], stateMutability: "nonpayable", type: "function", @@ -445,10 +575,36 @@ const _abi = [ stateMutability: "payable", type: "function", }, + { + inputs: [], + name: "zetaAsset", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "zetaConnector", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 3203cdfb..2b48d911 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -423,6 +423,11 @@ const _abi = [ name: "_tssAddress", type: "address", }, + { + internalType: "address", + name: "_zetaAsset", + type: "address", + }, ], name: "initialize", outputs: [], @@ -462,6 +467,19 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "address", + name: "_zetaConnector", + type: "address", + }, + ], + name: "setConnector", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -532,10 +550,36 @@ const _abi = [ stateMutability: "payable", type: "function", }, + { + inputs: [], + name: "zetaAsset", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "zetaConnector", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts new file mode 100644 index 00000000..5889be8f --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts @@ -0,0 +1,203 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZetaConnectorNew, + ZetaConnectorNewInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNew"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + { + internalType: "address", + name: "_zeta", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zeta", + outputs: [ + { + internalType: "contract IERC20", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZetaConnectorNewConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZetaConnectorNewConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZetaConnectorNew__factory extends ContractFactory { + constructor(...args: ZetaConnectorNewConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + _zeta: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + _gateway, + _zeta, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + _zeta: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, _zeta, overrides || {}); + } + override attach(address: string): ZetaConnectorNew { + return super.attach(address) as ZetaConnectorNew; + } + override connect(signer: Signer): ZetaConnectorNew__factory { + return super.connect(signer) as ZetaConnectorNew__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZetaConnectorNewInterface { + return new utils.Interface(_abi) as ZetaConnectorNewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNew { + return new Contract(address, _abi, signerOrProvider) as ZetaConnectorNew; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index b7a35400..ffd0d34a 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -7,3 +7,4 @@ export { GatewayEVM__factory } from "./GatewayEVM__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; +export { ZetaConnectorNew__factory } from "./ZetaConnectorNew__factory"; diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts index 3a79b828..8c196ce2 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -860,7 +860,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "0x60806040526001600c60006101000a81548160ff0219169083151502179055506001601f60006101000a81548160ff02191690831515021790555034801561004657600080fd5b50619915806100566000396000f3fe60806040523480156200001157600080fd5b5060043610620001005760003560e01c8063916a17c61162000099578063ba414fa6116200006f578063ba414fa61462000243578063e20c9f711462000265578063fa7626d41462000287578063fe7bdbb214620002a95762000100565b8063916a17c614620001dd578063b0464fdc14620001ff578063b5508aa914620002215762000100565b80633e5e3c2311620000db5780633e5e3c2314620001555780633f7286f4146200017757806366d9a9a0146200019957806385226c8114620001bb5762000100565b80630a9254e414620001055780631ed7831c14620001115780632ade38801462000133575b600080fd5b6200010f620002b5565b005b6200011b62000a02565b6040516200012a919062002257565b60405180910390f35b6200013d62000a92565b6040516200014c9190620022c3565b60405180910390f35b6200015f62000c2c565b6040516200016e919062002257565b60405180910390f35b6200018162000cbc565b60405162000190919062002257565b60405180910390f35b620001a362000d4c565b604051620001b291906200229f565b60405180910390f35b620001c562000ee3565b604051620001d491906200227b565b60405180910390f35b620001e762000fc6565b604051620001f69190620022e7565b60405180910390f35b6200020962001119565b604051620002189190620022e7565b60405180910390f35b6200022b6200126c565b6040516200023a91906200227b565b60405180910390f35b6200024d6200134f565b6040516200025c91906200230b565b60405180910390f35b6200026f62001482565b6040516200027e919062002257565b60405180910390f35b6200029162001512565b604051620002a091906200230b565b60405180910390f35b620002b362001525565b005b30602560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550611234602660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550615678602760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200038a90620018df565b620003959062002400565b604051809103906000f080158015620003b2573d6000803e3d6000fd5b50602360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200040190620018df565b6200040c90620023c9565b604051809103906000f08015801562000429573d6000803e3d6000fd5b50602460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506040516200047890620018ed565b604051809103906000f08015801562000495573d6000803e3d6000fd5b50601f60016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040516200050790620018fb565b6200051391906200210e565b604051809103906000f08015801562000530573d6000803e3d6000fd5b50602160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff16602460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16604051620005c59062001909565b620005d29291906200212b565b604051809103906000f080158015620005ef573d6000803e3d6000fd5b50602260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663485cc955602760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16602460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518363ffffffff1660e01b8152600401620006d39291906200212b565b600060405180830381600087803b158015620006ee57600080fd5b505af115801562000703573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663ae7a3a6f602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200078691906200210e565b600060405180830381600087803b158015620007a157600080fd5b505af1158015620007b6573d6000803e3d6000fd5b50505050601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166310188aef602260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b81526004016200083991906200210e565b600060405180830381600087803b1580156200085457600080fd5b505af115801562000869573d6000803e3d6000fd5b50505050602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19602560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16620f42406040518363ffffffff1660e01b8152600401620008f1929190620021b9565b600060405180830381600087803b1580156200090c57600080fd5b505af115801562000921573d6000803e3d6000fd5b50505050602360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb602160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166207a1206040518363ffffffff1660e01b8152600401620009a9929190620021e6565b602060405180830381600087803b158015620009c457600080fd5b505af1158015620009d9573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620009ff9190620019c3565b50565b6060601680548060200260200160405190810160405280929190818152602001828054801562000a8857602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000a3d575b5050505050905090565b6060601e805480602002602001604051908101604052809291908181526020016000905b8282101562000c2357838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020016000905b8282101562000c0b57838290600052602060002001805462000b779062002758565b80601f016020809104026020016040519081016040528092919081815260200182805462000ba59062002758565b801562000bf65780601f1062000bca5761010080835404028352916020019162000bf6565b820191906000526020600020905b81548152906001019060200180831162000bd857829003601f168201915b50505050508152602001906001019062000b55565b50505050815250508152602001906001019062000ab6565b50505050905090565b6060601880548060200260200160405190810160405280929190818152602001828054801562000cb257602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000c67575b5050505050905090565b6060601780548060200260200160405190810160405280929190818152602001828054801562000d4257602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001906001019080831162000cf7575b5050505050905090565b6060601b805480602002602001604051908101604052809291908181526020016000905b8282101562000eda578382906000526020600020906002020160405180604001604052908160008201805462000da69062002758565b80601f016020809104026020016040519081016040528092919081815260200182805462000dd49062002758565b801562000e255780601f1062000df95761010080835404028352916020019162000e25565b820191906000526020600020905b81548152906001019060200180831162000e0757829003601f168201915b505050505081526020016001820180548060200260200160405190810160405280929190818152602001828054801562000ec157602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19168152602001906004019060208260030104928301926001038202915080841162000e6d5790505b5050505050815250508152602001906001019062000d70565b50505050905090565b6060601a805480602002602001604051908101604052809291908181526020016000905b8282101562000fbd57838290600052602060002001805462000f299062002758565b80601f016020809104026020016040519081016040528092919081815260200182805462000f579062002758565b801562000fa85780601f1062000f7c5761010080835404028352916020019162000fa8565b820191906000526020600020905b81548152906001019060200180831162000f8a57829003601f168201915b50505050508152602001906001019062000f07565b50505050905090565b6060601d805480602002602001604051908101604052809291908181526020016000905b828210156200111057838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200160018201805480602002602001604051908101604052809291908181526020018280548015620010f757602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411620010a35790505b5050505050815250508152602001906001019062000fea565b50505050905090565b6060601c805480602002602001604051908101604052809291908181526020016000905b828210156200126357838290600052602060002090600202016040518060400160405290816000820160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001600182018054806020026020016040519081016040528092919081815260200182805480156200124a57602002820191906000526020600020906000905b82829054906101000a900460e01b7bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191681526020019060040190602082600301049283019260010382029150808411620011f65790505b505050505081525050815260200190600101906200113d565b50505050905090565b60606019805480602002602001604051908101604052809291908181526020016000905b8282101562001346578382906000526020600020018054620012b29062002758565b80601f0160208091040260200160405190810160405280929190818152602001828054620012e09062002758565b8015620013315780601f10620013055761010080835404028352916020019162001331565b820191906000526020600020905b8154815290600101906020018083116200131357829003601f168201915b50505050508152602001906001019062001290565b50505050905090565b6000600860009054906101000a900460ff16156200137f57600860009054906101000a900460ff1690506200147f565b6000801b7f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663667f9d707f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c7f6661696c656400000000000000000000000000000000000000000000000000006040518363ffffffff1660e01b81526004016200142692919062002158565b60206040518083038186803b1580156200143f57600080fd5b505afa15801562001454573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200147a9190620019f5565b141590505b90565b606060158054806020026020016040519081016040528092919081815260200182805480156200150857602002820191906000526020600020905b8160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019060010190808311620014bd575b5050505050905090565b601f60009054906101000a900460ff1681565b60006040518060400160405280600f81526020017f48656c6c6f2c20466f756e64727921000000000000000000000000000000000081525090506000602a90506000600190506000670de0b6b3a764000090506000848484604051602401620015919392919062002385565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff1663f30c7ba3602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684846040518463ffffffff1660e01b8152600401620016949392919062002213565b600060405180830381600087803b158015620016af57600080fd5b505af1158015620016c4573d6000803e3d6000fd5b505050507f885cb69240a935d632d79c317109709ecfa91a80626ff3989d68f67f5b1dd12d60001c73ffffffffffffffffffffffffffffffffffffffff166381bad6f3600180600180601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518663ffffffff1660e01b81526004016200175295949392919062002328565b600060405180830381600087803b1580156200176d57600080fd5b505af115801562001782573d6000803e3d6000fd5b50505050602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f8383604051620017f292919062002437565b60405180910390a2601f60019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16631cff79cd83602060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518463ffffffff1660e01b81526004016200187c92919062002185565b6000604051808303818588803b1580156200189657600080fd5b505af1158015620018ab573d6000803e3d6000fd5b50505050506040513d6000823e3d601f19601f82011682018060405250810190620018d7919062001a27565b505050505050565b611813806200292083390190565b613564806200413383390190565b611090806200769783390190565b6111b9806200872783390190565b60006200192e620019288462002494565b6200246b565b9050828152602081018484840111156200194d576200194c62002827565b5b6200195a84828562002722565b509392505050565b6000815190506200197381620028eb565b92915050565b6000815190506200198a8162002905565b92915050565b600082601f830112620019a857620019a762002822565b5b8151620019ba84826020860162001917565b91505092915050565b600060208284031215620019dc57620019db62002831565b5b6000620019ec8482850162001962565b91505092915050565b60006020828403121562001a0e5762001a0d62002831565b5b600062001a1e8482850162001979565b91505092915050565b60006020828403121562001a405762001a3f62002831565b5b600082015167ffffffffffffffff81111562001a615762001a606200282c565b5b62001a6f8482850162001990565b91505092915050565b600062001a86838362001b04565b60208301905092915050565b600062001aa0838362001ea1565b60208301905092915050565b600062001aba838362001f15565b905092915050565b600062001ad0838362002033565b905092915050565b600062001ae683836200207b565b905092915050565b600062001afc8383620020bc565b905092915050565b62001b0f816200267a565b82525050565b62001b20816200267a565b82525050565b600062001b33826200252a565b62001b3f8185620025d0565b935062001b4c83620024ca565b8060005b8381101562001b8357815162001b67888262001a78565b975062001b748362002582565b92505060018101905062001b50565b5085935050505092915050565b600062001b9d8262002535565b62001ba98185620025e1565b935062001bb683620024da565b8060005b8381101562001bed57815162001bd1888262001a92565b975062001bde836200258f565b92505060018101905062001bba565b5085935050505092915050565b600062001c078262002540565b62001c138185620025f2565b93508360208202850162001c2785620024ea565b8060005b8581101562001c69578484038952815162001c47858262001aac565b945062001c54836200259c565b925060208a0199505060018101905062001c2b565b50829750879550505050505092915050565b600062001c888262002540565b62001c94818562002603565b93508360208202850162001ca885620024ea565b8060005b8581101562001cea578484038952815162001cc8858262001aac565b945062001cd5836200259c565b925060208a0199505060018101905062001cac565b50829750879550505050505092915050565b600062001d09826200254b565b62001d15818562002614565b93508360208202850162001d2985620024fa565b8060005b8581101562001d6b578484038952815162001d49858262001ac2565b945062001d5683620025a9565b925060208a0199505060018101905062001d2d565b50829750879550505050505092915050565b600062001d8a8262002556565b62001d96818562002625565b93508360208202850162001daa856200250a565b8060005b8581101562001dec578484038952815162001dca858262001ad8565b945062001dd783620025b6565b925060208a0199505060018101905062001dae565b50829750879550505050505092915050565b600062001e0b8262002561565b62001e17818562002636565b93508360208202850162001e2b856200251a565b8060005b8581101562001e6d578484038952815162001e4b858262001aee565b945062001e5883620025c3565b925060208a0199505060018101905062001e2f565b50829750879550505050505092915050565b62001e8a816200268e565b82525050565b62001e9b816200269a565b82525050565b62001eac81620026a4565b82525050565b600062001ebf826200256c565b62001ecb818562002647565b935062001edd81856020860162002722565b62001ee88162002836565b840191505092915050565b62001efe81620026fa565b82525050565b62001f0f816200270e565b82525050565b600062001f228262002577565b62001f2e818562002658565b935062001f4081856020860162002722565b62001f4b8162002836565b840191505092915050565b600062001f638262002577565b62001f6f818562002669565b935062001f8181856020860162002722565b62001f8c8162002836565b840191505092915050565b600062001fa660038362002669565b915062001fb38262002847565b602082019050919050565b600062001fcd60048362002669565b915062001fda8262002870565b602082019050919050565b600062001ff460048362002669565b9150620020018262002899565b602082019050919050565b60006200201b60048362002669565b91506200202882620028c2565b602082019050919050565b6000604083016000830151848203600086015262002052828262001f15565b915050602083015184820360208601526200206e828262001b90565b9150508091505092915050565b600060408301600083015162002095600086018262001b04565b5060208301518482036020860152620020af828262001bfa565b9150508091505092915050565b6000604083016000830151620020d6600086018262001b04565b5060208301518482036020860152620020f0828262001b90565b9150508091505092915050565b6200210881620026f0565b82525050565b600060208201905062002125600083018462001b15565b92915050565b600060408201905062002142600083018562001b15565b62002151602083018462001b15565b9392505050565b60006040820190506200216f600083018562001b15565b6200217e602083018462001e90565b9392505050565b60006040820190506200219c600083018562001b15565b8181036020830152620021b0818462001eb2565b90509392505050565b6000604082019050620021d0600083018562001b15565b620021df602083018462001ef3565b9392505050565b6000604082019050620021fd600083018562001b15565b6200220c602083018462001f04565b9392505050565b60006060820190506200222a600083018662001b15565b620022396020830185620020fd565b81810360408301526200224d818462001eb2565b9050949350505050565b6000602082019050818103600083015262002273818462001b26565b905092915050565b6000602082019050818103600083015262002297818462001c7b565b905092915050565b60006020820190508181036000830152620022bb818462001cfc565b905092915050565b60006020820190508181036000830152620022df818462001d7d565b905092915050565b6000602082019050818103600083015262002303818462001dfe565b905092915050565b600060208201905062002322600083018462001e7f565b92915050565b600060a0820190506200233f600083018862001e7f565b6200234e602083018762001e7f565b6200235d604083018662001e7f565b6200236c606083018562001e7f565b6200237b608083018462001b15565b9695505050505050565b60006060820190508181036000830152620023a1818662001f56565b9050620023b26020830185620020fd565b620023c1604083018462001e7f565b949350505050565b60006040820190508181036000830152620023e48162001fbe565b90508181036020830152620023f98162001fe5565b9050919050565b600060408201905081810360008301526200241b816200200c565b90508181036020830152620024308162001f97565b9050919050565b60006040820190506200244e6000830185620020fd565b818103602083015262002462818462001eb2565b90509392505050565b6000620024776200248a565b90506200248582826200278e565b919050565b6000604051905090565b600067ffffffffffffffff821115620024b257620024b1620027f3565b5b620024bd8262002836565b9050602081019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b60006200268782620026d0565b9050919050565b60008115159050919050565b6000819050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006200270782620026f0565b9050919050565b60006200271b82620026f0565b9050919050565b60005b838110156200274257808201518184015260208101905062002725565b8381111562002752576000848401525b50505050565b600060028204905060018216806200277157607f821691505b60208210811415620027885762002787620027c4565b5b50919050565b620027998262002836565b810181811067ffffffffffffffff82111715620027bb57620027ba620027f3565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f54544b0000000000000000000000000000000000000000000000000000000000600082015250565b7f7a65746100000000000000000000000000000000000000000000000000000000600082015250565b7f5a45544100000000000000000000000000000000000000000000000000000000600082015250565b7f7465737400000000000000000000000000000000000000000000000000000000600082015250565b620028f6816200268e565b81146200290257600080fd5b50565b62002910816200269a565b81146200291c57600080fd5b5056fe60806040523480156200001157600080fd5b5060405162001813380380620018138339818101604052810190620000379190620001a3565b818181600390805190602001906200005192919062000075565b5080600490805190602001906200006a92919062000075565b5050505050620003ac565b8280546200008390620002bd565b90600052602060002090601f016020900481019282620000a75760008555620000f3565b82601f10620000c257805160ff1916838001178555620000f3565b82800160010185558215620000f3579182015b82811115620000f2578251825591602001919060010190620000d5565b5b50905062000102919062000106565b5090565b5b808211156200012157600081600090555060010162000107565b5090565b60006200013c620001368462000251565b62000228565b9050828152602081018484840111156200015b576200015a6200038c565b5b6200016884828562000287565b509392505050565b600082601f83011262000188576200018762000387565b5b81516200019a84826020860162000125565b91505092915050565b60008060408385031215620001bd57620001bc62000396565b5b600083015167ffffffffffffffff811115620001de57620001dd62000391565b5b620001ec8582860162000170565b925050602083015167ffffffffffffffff81111562000210576200020f62000391565b5b6200021e8582860162000170565b9150509250929050565b60006200023462000247565b9050620002428282620002f3565b919050565b6000604051905090565b600067ffffffffffffffff8211156200026f576200026e62000358565b5b6200027a826200039b565b9050602081019050919050565b60005b83811015620002a75780820151818401526020810190506200028a565b83811115620002b7576000848401525b50505050565b60006002820490506001821680620002d657607f821691505b60208210811415620002ed57620002ec62000329565b5b50919050565b620002fe826200039b565b810181811067ffffffffffffffff8211171562000320576200031f62000358565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b61145780620003bc6000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c806340c10f191161007157806340c10f19146101a357806370a08231146101bf57806395d89b41146101ef578063a457c2d71461020d578063a9059cbb1461023d578063dd62ed3e1461026d576100b4565b806306fdde03146100b9578063095ea7b3146100d757806318160ddd1461010757806323b872dd14610125578063313ce567146101555780633950935114610173575b600080fd5b6100c161029d565b6040516100ce9190610ecf565b60405180910390f35b6100f160048036038101906100ec9190610cf6565b61032f565b6040516100fe9190610eb4565b60405180910390f35b61010f610352565b60405161011c9190610ff1565b60405180910390f35b61013f600480360381019061013a9190610ca3565b61035c565b60405161014c9190610eb4565b60405180910390f35b61015d61038b565b60405161016a919061100c565b60405180910390f35b61018d60048036038101906101889190610cf6565b610394565b60405161019a9190610eb4565b60405180910390f35b6101bd60048036038101906101b89190610cf6565b6103cb565b005b6101d960048036038101906101d49190610c36565b6103d9565b6040516101e69190610ff1565b60405180910390f35b6101f7610421565b6040516102049190610ecf565b60405180910390f35b61022760048036038101906102229190610cf6565b6104b3565b6040516102349190610eb4565b60405180910390f35b61025760048036038101906102529190610cf6565b61052a565b6040516102649190610eb4565b60405180910390f35b61028760048036038101906102829190610c63565b61054d565b6040516102949190610ff1565b60405180910390f35b6060600380546102ac90611121565b80601f01602080910402602001604051908101604052809291908181526020018280546102d890611121565b80156103255780601f106102fa57610100808354040283529160200191610325565b820191906000526020600020905b81548152906001019060200180831161030857829003601f168201915b5050505050905090565b60008061033a6105d4565b90506103478185856105dc565b600191505092915050565b6000600254905090565b6000806103676105d4565b90506103748582856107a7565b61037f858585610833565b60019150509392505050565b60006012905090565b60008061039f6105d4565b90506103c08185856103b1858961054d565b6103bb9190611043565b6105dc565b600191505092915050565b6103d58282610aab565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b60606004805461043090611121565b80601f016020809104026020016040519081016040528092919081815260200182805461045c90611121565b80156104a95780601f1061047e576101008083540402835291602001916104a9565b820191906000526020600020905b81548152906001019060200180831161048c57829003601f168201915b5050505050905090565b6000806104be6105d4565b905060006104cc828661054d565b905083811015610511576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050890610fb1565b60405180910390fd5b61051e82868684036105dc565b60019250505092915050565b6000806105356105d4565b9050610542818585610833565b600191505092915050565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16141561064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610f91565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156106bc576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106b390610f11565b60405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9258360405161079a9190610ff1565b60405180910390a3505050565b60006107b3848461054d565b90507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff811461082d578181101561081f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161081690610f31565b60405180910390fd5b61082c84848484036105dc565b5b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156108a3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161089a90610f71565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610913576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090a90610ef1565b60405180910390fd5b61091e838383610c02565b60008060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050818110156109a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161099b90610f51565b60405180910390fd5b8181036000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508273ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef84604051610a929190610ff1565b60405180910390a3610aa5848484610c07565b50505050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610b1b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b1290610fd1565b60405180910390fd5b610b2760008383610c02565b8060026000828254610b399190611043565b92505081905550806000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef83604051610bea9190610ff1565b60405180910390a3610bfe60008383610c07565b5050565b505050565b505050565b600081359050610c1b816113f3565b92915050565b600081359050610c308161140a565b92915050565b600060208284031215610c4c57610c4b6111b1565b5b6000610c5a84828501610c0c565b91505092915050565b60008060408385031215610c7a57610c796111b1565b5b6000610c8885828601610c0c565b9250506020610c9985828601610c0c565b9150509250929050565b600080600060608486031215610cbc57610cbb6111b1565b5b6000610cca86828701610c0c565b9350506020610cdb86828701610c0c565b9250506040610cec86828701610c21565b9150509250925092565b60008060408385031215610d0d57610d0c6111b1565b5b6000610d1b85828601610c0c565b9250506020610d2c85828601610c21565b9150509250929050565b610d3f816110ab565b82525050565b6000610d5082611027565b610d5a8185611032565b9350610d6a8185602086016110ee565b610d73816111b6565b840191505092915050565b6000610d8b602383611032565b9150610d96826111c7565b604082019050919050565b6000610dae602283611032565b9150610db982611216565b604082019050919050565b6000610dd1601d83611032565b9150610ddc82611265565b602082019050919050565b6000610df4602683611032565b9150610dff8261128e565b604082019050919050565b6000610e17602583611032565b9150610e22826112dd565b604082019050919050565b6000610e3a602483611032565b9150610e458261132c565b604082019050919050565b6000610e5d602583611032565b9150610e688261137b565b604082019050919050565b6000610e80601f83611032565b9150610e8b826113ca565b602082019050919050565b610e9f816110d7565b82525050565b610eae816110e1565b82525050565b6000602082019050610ec96000830184610d36565b92915050565b60006020820190508181036000830152610ee98184610d45565b905092915050565b60006020820190508181036000830152610f0a81610d7e565b9050919050565b60006020820190508181036000830152610f2a81610da1565b9050919050565b60006020820190508181036000830152610f4a81610dc4565b9050919050565b60006020820190508181036000830152610f6a81610de7565b9050919050565b60006020820190508181036000830152610f8a81610e0a565b9050919050565b60006020820190508181036000830152610faa81610e2d565b9050919050565b60006020820190508181036000830152610fca81610e50565b9050919050565b60006020820190508181036000830152610fea81610e73565b9050919050565b60006020820190506110066000830184610e96565b92915050565b60006020820190506110216000830184610ea5565b92915050565b600081519050919050565b600082825260208201905092915050565b600061104e826110d7565b9150611059836110d7565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561108e5761108d611153565b5b828201905092915050565b60006110a4826110b7565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60005b8381101561110c5780820151818401526020810190506110f1565b8381111561111b576000848401525b50505050565b6000600282049050600182168061113957607f821691505b6020821081141561114d5761114c611182565b5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b600080fd5b6000601f19601f8301169050919050565b7f45524332303a207472616e7366657220746f20746865207a65726f206164647260008201527f6573730000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f766520746f20746865207a65726f20616464726560008201527f7373000000000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20696e73756666696369656e7420616c6c6f77616e6365000000600082015250565b7f45524332303a207472616e7366657220616d6f756e742065786365656473206260008201527f616c616e63650000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a207472616e736665722066726f6d20746865207a65726f20616460008201527f6472657373000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a20617070726f76652066726f6d20746865207a65726f2061646460008201527f7265737300000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f7760008201527f207a65726f000000000000000000000000000000000000000000000000000000602082015250565b7f45524332303a206d696e7420746f20746865207a65726f206164647265737300600082015250565b6113fc81611099565b811461140757600080fd5b50565b611413816110d7565b811461141e57600080fd5b5056fea2646970667358221220d4c96329400732e284f624232c8d7228fc90c00ee7b1a48a85080262107815d864736f6c6343000807003360a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c6134e361008160003960008181610768015281816107f701528181610b2201528181610bb10152610fcd01526134e36000f3fe60806040526004361061011f5760003560e01c80635b112591116100a0578063dda79b7511610064578063dda79b7514610382578063f2fde38b146103ad578063f31e62bf146103d6578063f340fa0114610401578063f45346dc1461041d5761011f565b80635b112591146102c3578063715018a6146102ee5780638c6f037f146103055780638da5cb5b1461032e578063ae7a3a6f146103595761011f565b8063485cc955116100e7578063485cc955146101eb5780634f1ef286146102145780635131ab591461023057806352d1902d1461026d57806357bec62f146102985761011f565b806310188aef146101245780631b8b921d1461014d5780631cff79cd1461017657806329c59b5d146101a65780633659cfe6146101c2575b600080fd5b34801561013057600080fd5b5061014b6004803603810190610146919061244e565b610446565b005b34801561015957600080fd5b50610174600480360381019061016f9190612543565b610512565b005b610190600480360381019061018b9190612543565b61057e565b60405161019d9190612bd6565b60405180910390f35b6101c060048036038101906101bb9190612543565b6105ec565b005b3480156101ce57600080fd5b506101e960048036038101906101e4919061244e565b610766565b005b3480156101f757600080fd5b50610212600480360381019061020d919061247b565b6108ef565b005b61022e600480360381019061022991906125a3565b610b20565b005b34801561023c57600080fd5b50610257600480360381019061025291906124bb565b610c5d565b6040516102649190612bd6565b60405180910390f35b34801561027957600080fd5b50610282610fc9565b60405161028f9190612b97565b60405180910390f35b3480156102a457600080fd5b506102ad611082565b6040516102ba9190612af3565b60405180910390f35b3480156102cf57600080fd5b506102d86110a8565b6040516102e59190612af3565b60405180910390f35b3480156102fa57600080fd5b506103036110ce565b005b34801561031157600080fd5b5061032c60048036038101906103279190612652565b6110e2565b005b34801561033a57600080fd5b50610343611260565b6040516103509190612af3565b60405180910390f35b34801561036557600080fd5b50610380600480360381019061037b919061244e565b61128a565b005b34801561038e57600080fd5b50610397611356565b6040516103a49190612af3565b60405180910390f35b3480156103b957600080fd5b506103d460048036038101906103cf919061244e565b61137c565b005b3480156103e257600080fd5b506103eb611400565b6040516103f89190612af3565b60405180910390f35b61041b6004803603810190610416919061244e565b611426565b005b34801561042957600080fd5b50610444600480360381019061043f91906125ff565b61159a565b005b600073ffffffffffffffffffffffffffffffffffffffff1660cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146104ce576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060cb60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde38484604051610571929190612bb2565b60405180910390a3505050565b6060600061058d858585611712565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f3486866040516105d993929190612e51565b60405180910390a2809150509392505050565b6000341415610627576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163460405161066f90612ade565b60006040518083038185875af1925050503d80600081146106ac576040519150601f19603f3d011682016040523d82523d6000602084013e6106b1565b606091505b505090506000151581151514156106f4576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516107589493929190612dd5565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156107f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ec90612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166108346117c9565b73ffffffffffffffffffffffffffffffffffffffff161461088a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161088190612c75565b60405180910390fd5b61089381611820565b6108ec81600067ffffffffffffffff8111156108b2576108b1613012565b5b6040519080825280601f01601f1916602001820160405280156108e45781602001600182028036833780820191505090505b50600061182b565b50565b60008060019054906101000a900460ff161590508080156109205750600160008054906101000a900460ff1660ff16105b8061094d575061092f306119a8565b15801561094c5750600160008054906101000a900460ff1660ff16145b5b61098c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161098390612cf5565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109c9576001600060016101000a81548160ff0219169083151502179055505b6109d16119cb565b6109d9611a24565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610a40576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8260ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508160cc60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610b1b5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610b129190612bf8565b60405180910390a15b505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610baf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ba690612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610bee6117c9565b73ffffffffffffffffffffffffffffffffffffffff1614610c44576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c3b90612c75565b60405180910390fd5b610c4d82611820565b610c598282600161182b565b5050565b60606000841415610c9a576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610ca48686611a75565b610cda576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610d15929190612b6e565b602060405180830381600087803b158015610d2f57600080fd5b505af1158015610d43573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d6791906126da565b610d9d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610daa868585611712565b9050610db68787611a75565b610dec576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610e279190612af3565b60206040518083038186803b158015610e3f57600080fd5b505afa158015610e53573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e779190612734565b90506000811115610f5257600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168973ffffffffffffffffffffffffffffffffffffffff161415610f255760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b610f5081838b73ffffffffffffffffffffffffffffffffffffffff16611b0d9092919063ffffffff16565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610fb393929190612e51565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614611059576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161105090612cb5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110d6611b93565b6110e06000611c11565b565b600084141561111d576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156111c05760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6111ed3382878773ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8573ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4878787876040516112509493929190612dd5565b60405180910390a3505050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611312576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b611384611b93565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156113f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113eb90612c35565b60405180910390fd5b6113fd81611c11565b50565b60cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000341415611461576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516114a990612ade565b60006040518083038185875af1925050503d80600081146114e6576040519150601f19603f3d011682016040523d82523d6000602084013e6114eb565b606091505b5050905060001515811515141561152e576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600060405161158e929190612e15565b60405180910390a35050565b60008214156115d5576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116785760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6116a53382858573ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48585604051611704929190612e15565b60405180910390a350505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1634868660405161173f929190612aae565b60006040518083038185875af1925050503d806000811461177c576040519150601f19603f3d011682016040523d82523d6000602084013e611781565b606091505b5091509150816117bd576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006117f77f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b611828611b93565b50565b6118577f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611d6a565b60000160009054906101000a900460ff161561187b5761187683611d74565b6119a3565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156118c157600080fd5b505afa9250505080156118f257506040513d601f19601f820116820180604052508101906118ef9190612707565b60015b611931576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161192890612d15565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611996576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161198d90612cd5565b60405180910390fd5b506119a2838383611e2d565b5b505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611a1a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a1190612d95565b60405180910390fd5b611a22611e59565b565b600060019054906101000a900460ff16611a73576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a6a90612d95565b60405180910390fd5b565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611ab3929190612b45565b602060405180830381600087803b158015611acd57600080fd5b505af1158015611ae1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b0591906126da565b905092915050565b611b8e8363a9059cbb60e01b8484604051602401611b2c929190612b6e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b505050565b611b9b611f81565b73ffffffffffffffffffffffffffffffffffffffff16611bb9611260565b73ffffffffffffffffffffffffffffffffffffffff1614611c0f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c0690612d55565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b611d5a846323b872dd60e01b858585604051602401611cf893929190612b0e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b50505050565b6000819050919050565b6000819050919050565b611d7d816119a8565b611dbc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611db390612d35565b60405180910390fd5b80611de97f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611e3683611f89565b600082511180611e435750805b15611e5457611e528383611fd8565b505b505050565b600060019054906101000a900460ff16611ea8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e9f90612d95565b60405180910390fd5b611eb8611eb3611f81565b611c11565b565b6000611f1c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166120059092919063ffffffff16565b9050600081511115611f7c5780806020019051810190611f3c91906126da565b611f7b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f7290612db5565b60405180910390fd5b5b505050565b600033905090565b611f9281611d74565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611ffd83836040518060600160405280602781526020016134876027913961201d565b905092915050565b606061201484846000856120a3565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516120479190612ac7565b600060405180830381855af49150503d8060008114612082576040519150601f19603f3d011682016040523d82523d6000602084013e612087565b606091505b509150915061209886838387612170565b925050509392505050565b6060824710156120e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120df90612c95565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516121119190612ac7565b60006040518083038185875af1925050503d806000811461214e576040519150601f19603f3d011682016040523d82523d6000602084013e612153565b606091505b5091509150612164878383876121e6565b92505050949350505050565b606083156121d3576000835114156121cb5761218b856119a8565b6121ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121c190612d75565b60405180910390fd5b5b8290506121de565b6121dd838361225c565b5b949350505050565b606083156122495760008351141561224157612201856122ac565b612240576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161223790612d75565b60405180910390fd5b5b829050612254565b61225383836122cf565b5b949350505050565b60008251111561226f5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122a39190612c13565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156122e25781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123169190612c13565b60405180910390fd5b600061233261232d84612ea8565b612e83565b90508281526020810184848401111561234e5761234d613050565b5b612359848285612f9f565b509392505050565b6000813590506123708161342a565b92915050565b60008151905061238581613441565b92915050565b60008151905061239a81613458565b92915050565b60008083601f8401126123b6576123b5613046565b5b8235905067ffffffffffffffff8111156123d3576123d2613041565b5b6020830191508360018202830111156123ef576123ee61304b565b5b9250929050565b600082601f83011261240b5761240a613046565b5b813561241b84826020860161231f565b91505092915050565b6000813590506124338161346f565b92915050565b6000815190506124488161346f565b92915050565b6000602082840312156124645761246361305a565b5b600061247284828501612361565b91505092915050565b600080604083850312156124925761249161305a565b5b60006124a085828601612361565b92505060206124b185828601612361565b9150509250929050565b6000806000806000608086880312156124d7576124d661305a565b5b60006124e588828901612361565b95505060206124f688828901612361565b945050604061250788828901612424565b935050606086013567ffffffffffffffff81111561252857612527613055565b5b612534888289016123a0565b92509250509295509295909350565b60008060006040848603121561255c5761255b61305a565b5b600061256a86828701612361565b935050602084013567ffffffffffffffff81111561258b5761258a613055565b5b612597868287016123a0565b92509250509250925092565b600080604083850312156125ba576125b961305a565b5b60006125c885828601612361565b925050602083013567ffffffffffffffff8111156125e9576125e8613055565b5b6125f5858286016123f6565b9150509250929050565b6000806000606084860312156126185761261761305a565b5b600061262686828701612361565b935050602061263786828701612424565b925050604061264886828701612361565b9150509250925092565b60008060008060006080868803121561266e5761266d61305a565b5b600061267c88828901612361565b955050602061268d88828901612424565b945050604061269e88828901612361565b935050606086013567ffffffffffffffff8111156126bf576126be613055565b5b6126cb888289016123a0565b92509250509295509295909350565b6000602082840312156126f0576126ef61305a565b5b60006126fe84828501612376565b91505092915050565b60006020828403121561271d5761271c61305a565b5b600061272b8482850161238b565b91505092915050565b60006020828403121561274a5761274961305a565b5b600061275884828501612439565b91505092915050565b61276a81612f1c565b82525050565b61277981612f3a565b82525050565b600061278b8385612eef565b9350612798838584612f9f565b6127a18361305f565b840190509392505050565b60006127b88385612f00565b93506127c5838584612f9f565b82840190509392505050565b60006127dc82612ed9565b6127e68185612eef565b93506127f6818560208601612fae565b6127ff8161305f565b840191505092915050565b600061281582612ed9565b61281f8185612f00565b935061282f818560208601612fae565b80840191505092915050565b61284481612f7b565b82525050565b61285381612f8d565b82525050565b600061286482612ee4565b61286e8185612f0b565b935061287e818560208601612fae565b6128878161305f565b840191505092915050565b600061289f602683612f0b565b91506128aa82613070565b604082019050919050565b60006128c2602c83612f0b565b91506128cd826130bf565b604082019050919050565b60006128e5602c83612f0b565b91506128f08261310e565b604082019050919050565b6000612908602683612f0b565b91506129138261315d565b604082019050919050565b600061292b603883612f0b565b9150612936826131ac565b604082019050919050565b600061294e602983612f0b565b9150612959826131fb565b604082019050919050565b6000612971602e83612f0b565b915061297c8261324a565b604082019050919050565b6000612994602e83612f0b565b915061299f82613299565b604082019050919050565b60006129b7602d83612f0b565b91506129c2826132e8565b604082019050919050565b60006129da602083612f0b565b91506129e582613337565b602082019050919050565b60006129fd600083612eef565b9150612a0882613360565b600082019050919050565b6000612a20600083612f00565b9150612a2b82613360565b600082019050919050565b6000612a43601d83612f0b565b9150612a4e82613363565b602082019050919050565b6000612a66602b83612f0b565b9150612a718261338c565b604082019050919050565b6000612a89602a83612f0b565b9150612a94826133db565b604082019050919050565b612aa881612f64565b82525050565b6000612abb8284866127ac565b91508190509392505050565b6000612ad3828461280a565b915081905092915050565b6000612ae982612a13565b9150819050919050565b6000602082019050612b086000830184612761565b92915050565b6000606082019050612b236000830186612761565b612b306020830185612761565b612b3d6040830184612a9f565b949350505050565b6000604082019050612b5a6000830185612761565b612b67602083018461283b565b9392505050565b6000604082019050612b836000830185612761565b612b906020830184612a9f565b9392505050565b6000602082019050612bac6000830184612770565b92915050565b60006020820190508181036000830152612bcd81848661277f565b90509392505050565b60006020820190508181036000830152612bf081846127d1565b905092915050565b6000602082019050612c0d600083018461284a565b92915050565b60006020820190508181036000830152612c2d8184612859565b905092915050565b60006020820190508181036000830152612c4e81612892565b9050919050565b60006020820190508181036000830152612c6e816128b5565b9050919050565b60006020820190508181036000830152612c8e816128d8565b9050919050565b60006020820190508181036000830152612cae816128fb565b9050919050565b60006020820190508181036000830152612cce8161291e565b9050919050565b60006020820190508181036000830152612cee81612941565b9050919050565b60006020820190508181036000830152612d0e81612964565b9050919050565b60006020820190508181036000830152612d2e81612987565b9050919050565b60006020820190508181036000830152612d4e816129aa565b9050919050565b60006020820190508181036000830152612d6e816129cd565b9050919050565b60006020820190508181036000830152612d8e81612a36565b9050919050565b60006020820190508181036000830152612dae81612a59565b9050919050565b60006020820190508181036000830152612dce81612a7c565b9050919050565b6000606082019050612dea6000830187612a9f565b612df76020830186612761565b8181036040830152612e0a81848661277f565b905095945050505050565b6000606082019050612e2a6000830185612a9f565b612e376020830184612761565b8181036040830152612e48816129f0565b90509392505050565b6000604082019050612e666000830186612a9f565b8181036020830152612e7981848661277f565b9050949350505050565b6000612e8d612e9e565b9050612e998282612fe1565b919050565b6000604051905090565b600067ffffffffffffffff821115612ec357612ec2613012565b5b612ecc8261305f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612f2782612f44565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612f8682612f64565b9050919050565b6000612f9882612f6e565b9050919050565b82818337600083830152505050565b60005b83811015612fcc578082015181840152602081019050612fb1565b83811115612fdb576000848401525b50505050565b612fea8261305f565b810181811067ffffffffffffffff8211171561300957613008613012565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61343381612f1c565b811461343e57600080fd5b50565b61344a81612f2e565b811461345557600080fd5b50565b61346181612f3a565b811461346c57600080fd5b50565b61347881612f64565b811461348357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220a92291d9031c32880ffc1e5010a2c6663dffc6271b359692f77d40a3df8488cc64736f6c6343000807003360806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea2646970667358221220c6f7c0f9935341aaaabcabf7504d01bbd38a0606132004742a97e6a200eb432564736f6c6343000807003360806040523480156200001157600080fd5b50604051620011b9380380620011b9833981810160405281019062000037919062000180565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161480620000a75750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15620000df576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050506200021a565b6000815190506200017a8162000200565b92915050565b600080604083850312156200019a5762000199620001fb565b5b6000620001aa8582860162000169565b9250506020620001bd8582860162000169565b9150509250929050565b6000620001d482620001db565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200020b81620001c7565b81146200021757600080fd5b50565b610f8f806200022a6000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806302a04c0d14610051578063116191b61461006d578063e8f9cb3a1461008b578063f3fef3a3146100a9575b600080fd5b61006b6004803603810190610066919061082e565b6100c5565b005b610075610279565b6040516100829190610b20565b60405180910390f35b61009361029f565b6040516100a09190610b05565b60405180910390f35b6100c360048036038101906100be91906107ee565b6102c5565b005b6100cd610374565b61013c600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab59600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868686866040518663ffffffff1660e01b81526004016101c1959493929190610a8e565b600060405180830381600087803b1580156101db57600080fd5b505af11580156101ef573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f8201168201806040525081019061021891906108cf565b508373ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced84848460405161026393929190610bf8565b60405180910390a261027361044a565b50505050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6102cd610374565b61031a8282600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364826040516103609190610bdd565b60405180910390a261037061044a565b5050565b600260005414156103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103b190610bbd565b60405180910390fd5b6002600081905550565b6104458363a9059cbb60e01b84846040516024016103e3929190610adc565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610454565b505050565b6001600081905550565b60006104b6826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661051b9092919063ffffffff16565b905060008151111561051657808060200190518101906104d691906108a2565b610515576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050c90610b9d565b60405180910390fd5b5b505050565b606061052a8484600085610533565b90509392505050565b606082471015610578576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056f90610b5d565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516105a19190610a77565b60006040518083038185875af1925050503d80600081146105de576040519150601f19603f3d011682016040523d82523d6000602084013e6105e3565b606091505b50915091506105f487838387610600565b92505050949350505050565b606083156106635760008351141561065b5761061b85610676565b61065a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065190610b7d565b60405180910390fd5b5b82905061066e565b61066d8383610699565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106ac5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106e09190610b3b565b60405180910390fd5b60006106fc6106f784610c4f565b610c2a565b90508281526020810184848401111561071857610717610e04565b5b610723848285610d62565b509392505050565b60008135905061073a81610f14565b92915050565b60008151905061074f81610f2b565b92915050565b60008083601f84011261076b5761076a610dfa565b5b8235905067ffffffffffffffff81111561078857610787610df5565b5b6020830191508360018202830111156107a4576107a3610dff565b5b9250929050565b600082601f8301126107c0576107bf610dfa565b5b81516107d08482602086016106e9565b91505092915050565b6000813590506107e881610f42565b92915050565b6000806040838503121561080557610804610e0e565b5b60006108138582860161072b565b9250506020610824858286016107d9565b9150509250929050565b6000806000806060858703121561084857610847610e0e565b5b60006108568782880161072b565b9450506020610867878288016107d9565b935050604085013567ffffffffffffffff81111561088857610887610e09565b5b61089487828801610755565b925092505092959194509250565b6000602082840312156108b8576108b7610e0e565b5b60006108c684828501610740565b91505092915050565b6000602082840312156108e5576108e4610e0e565b5b600082015167ffffffffffffffff81111561090357610902610e09565b5b61090f848285016107ab565b91505092915050565b61092181610cc3565b82525050565b60006109338385610c96565b9350610940838584610d53565b61094983610e13565b840190509392505050565b600061095f82610c80565b6109698185610ca7565b9350610979818560208601610d62565b80840191505092915050565b61098e81610d0b565b82525050565b61099d81610d1d565b82525050565b60006109ae82610c8b565b6109b88185610cb2565b93506109c8818560208601610d62565b6109d181610e13565b840191505092915050565b60006109e9602683610cb2565b91506109f482610e24565b604082019050919050565b6000610a0c601d83610cb2565b9150610a1782610e73565b602082019050919050565b6000610a2f602a83610cb2565b9150610a3a82610e9c565b604082019050919050565b6000610a52601f83610cb2565b9150610a5d82610eeb565b602082019050919050565b610a7181610d01565b82525050565b6000610a838284610954565b915081905092915050565b6000608082019050610aa36000830188610918565b610ab06020830187610918565b610abd6040830186610a68565b8181036060830152610ad0818486610927565b90509695505050505050565b6000604082019050610af16000830185610918565b610afe6020830184610a68565b9392505050565b6000602082019050610b1a6000830184610985565b92915050565b6000602082019050610b356000830184610994565b92915050565b60006020820190508181036000830152610b5581846109a3565b905092915050565b60006020820190508181036000830152610b76816109dc565b9050919050565b60006020820190508181036000830152610b96816109ff565b9050919050565b60006020820190508181036000830152610bb681610a22565b9050919050565b60006020820190508181036000830152610bd681610a45565b9050919050565b6000602082019050610bf26000830184610a68565b92915050565b6000604082019050610c0d6000830186610a68565b8181036020830152610c20818486610927565b9050949350505050565b6000610c34610c45565b9050610c408282610d95565b919050565b6000604051905090565b600067ffffffffffffffff821115610c6a57610c69610dc6565b5b610c7382610e13565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610cce82610ce1565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610d1682610d2f565b9050919050565b6000610d2882610d2f565b9050919050565b6000610d3a82610d41565b9050919050565b6000610d4c82610ce1565b9050919050565b82818337600083830152505050565b60005b83811015610d80578082015181840152602081019050610d65565b83811115610d8f576000848401525b50505050565b610d9e82610e13565b810181811067ffffffffffffffff82111715610dbd57610dbc610dc6565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610f1d81610cc3565b8114610f2857600080fd5b50565b610f3481610cd5565b8114610f3f57600080fd5b50565b610f4b81610d01565b8114610f5657600080fd5b5056fea2646970667358221220bdea1bc357822401542c5c1b57f5c8696f7fa6c99ecfef1bfd392504260c0f1164736f6c63430008070033a2646970667358221220264a9183735d5bd804e168bb3039579c26f15ab1311c272005e87d8a2fd4fd7f64736f6c63430008070033"; type GatewayEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index 51673daa..d435ca66 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -963,7 +963,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 16dbcf6f..f8d925c5 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -368,6 +368,10 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ZetaConnectorNew", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayEVMTest", signerOrOptions?: ethers.Signer | FactoryOptions @@ -986,6 +990,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ZetaConnectorNew", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayEVMTest", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index eca804b4..d5442a89 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -176,6 +176,8 @@ export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; +export type { ZetaConnectorNew } from "./contracts/prototypes/evm/ZetaConnectorNew"; +export { ZetaConnectorNew__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNew__factory"; export type { GatewayEVMTest } from "./contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest"; export { GatewayEVMTest__factory } from "./factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory"; export type { GatewayEVMZEVMTest } from "./contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest"; From 0e03d108e65ca7b3484776d240e6496e5bbe3e72 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 9 Jul 2024 22:15:12 +0200 Subject: [PATCH 72/86] zeta withdraw zevm --- contracts/prototypes/zevm/GatewayZEVM.sol | 35 ++++- contracts/prototypes/zevm/interfaces.sol | 4 +- foundry.toml | 3 +- .../gatewayevmzevmtest.go | 17 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 132 ++++++++++++---- .../zevm/interfaces.sol/igatewayzevmerrors.go | 2 +- .../zevm/interfaces.sol/igatewayzevmevents.go | 15 +- .../zevm/senderzevm.sol/senderzevm.go | 2 +- scripts/worker.ts | 4 +- test/fuzz/ERC20CustodyNewEchidnaTest.sol | 2 +- test/fuzz/GatewayEVMEchidnaTest.sol | 2 +- test/prototypes/GatewayIntegration.spec.ts | 15 +- test/prototypes/GatewayZEVM.spec.ts | 10 +- .../GatewayEVMZEVMTest.ts | 9 +- .../contracts/prototypes/zevm/GatewayZEVM.ts | 146 +++++++++++++++--- .../zevm/interfaces.sol/IGatewayZEVMEvents.ts | 9 +- .../GatewayEVMZEVMTest__factory.ts | 18 ++- .../prototypes/zevm/GatewayZEVM__factory.ts | 70 ++++++++- .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../IGatewayZEVMErrors__factory.ts | 10 ++ .../IGatewayZEVMEvents__factory.ts | 6 + 21 files changed, 414 insertions(+), 99 deletions(-) diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 274b440e..6b8f872b 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -7,25 +7,29 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "../../zevm/interfaces/IZRC20.sol"; import "../../zevm/interfaces/zContract.sol"; import "./interfaces.sol"; +import "../../zevm/interfaces/IWZETA.sol"; + // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, OwnableUpgradeable, UUPSUpgradeable { address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; + address public wzeta; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } - function initialize() public initializer { + function initialize(address _wzeta) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); + wzeta = wzeta; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} - function _withdraw(uint256 amount, address zrc20) internal returns (uint256) { + function _withdrawZRC20(uint256 amount, address zrc20) internal returns (uint256) { (address gasZRC20, uint256 gasFee) = IZRC20(zrc20).withdrawGasFee(); if (!IZRC20(gasZRC20).transferFrom(msg.sender, FUNGIBLE_MODULE_ADDRESS, gasFee)) { revert GasFeeTransferFailed(); @@ -40,16 +44,35 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O return gasFee; } + function _withdrawZETA(uint256 amount) internal { + if (!IWETH9(wzeta).transferFrom(msg.sender, address(this), amount)) revert WZETATransferFailed(); + IWETH9(wzeta).withdraw(amount); + (bool sent, ) = FUNGIBLE_MODULE_ADDRESS.call{value: amount}(""); + if (!sent) revert FailedZetaSent(); + } + // Withdraw ZRC20 tokens to external chain function withdraw(bytes memory receiver, uint256 amount, address zrc20) external { - uint256 gasFee = _withdraw(amount, zrc20); - emit Withdrawal(msg.sender, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), ""); + uint256 gasFee = _withdrawZRC20(amount, zrc20); + emit Withdrawal(msg.sender, zrc20, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), ""); } // Withdraw ZRC20 tokens and call smart contract on external chain function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external { - uint256 gasFee = _withdraw(amount, zrc20); - emit Withdrawal(msg.sender, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), message); + uint256 gasFee = _withdrawZRC20(amount, zrc20); + emit Withdrawal(msg.sender, zrc20, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), message); + } + + // Withdraw ZETA to external chain + function withdraw(uint256 amount) external { + _withdrawZETA(amount); + emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, ""); + } + + // Withdraw ZETA and call smart contract on external chain + function withdrawAndCall(uint256 amount, bytes calldata message) external { + _withdrawZETA(amount); + emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, message); } // Call smart contract on external chain without asset transfer diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/interfaces.sol index bc4be8aa..fda7bcae 100644 --- a/contracts/prototypes/zevm/interfaces.sol +++ b/contracts/prototypes/zevm/interfaces.sol @@ -35,7 +35,7 @@ interface IGatewayZEVM { interface IGatewayZEVMEvents { event Call(address indexed sender, bytes receiver, bytes message); - event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); + event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); } interface IGatewayZEVMErrors { @@ -46,4 +46,6 @@ interface IGatewayZEVMErrors { error GasFeeTransferFailed(); error CallerIsNotFungibleModule(); error InvalidTarget(); + error WZETATransferFailed(); + error FailedZetaSent(); } \ No newline at end of file diff --git a/foundry.toml b/foundry.toml index 9f6482d0..5c1df4c3 100644 --- a/foundry.toml +++ b/foundry.toml @@ -4,4 +4,5 @@ out = 'out' libs = ['node_modules', 'lib'] test = 'test' cache_path = 'cache_forge' -no-match-contract = '.*EchidnaTest$' \ No newline at end of file +no-match-contract = '.*EchidnaTest$' +auto_detect_solc = true \ No newline at end of file diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 72455345..a5e7dd0e 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -49,8 +49,8 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. @@ -2007,6 +2007,7 @@ func (it *GatewayEVMZEVMTestWithdrawalIterator) Close() error { // GatewayEVMZEVMTestWithdrawal represents a Withdrawal event raised by the GatewayEVMZEVMTest contract. type GatewayEVMZEVMTestWithdrawal struct { From common.Address + Zrc20 common.Address To []byte Value *big.Int Gasfee *big.Int @@ -2015,9 +2016,9 @@ type GatewayEVMZEVMTestWithdrawal struct { Raw types.Log // Blockchain specific contextual infos } -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayEVMZEVMTestWithdrawalIterator, error) { var fromRule []interface{} @@ -2032,9 +2033,9 @@ func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) FilterWithdrawal(opts *bi return &GatewayEVMZEVMTestWithdrawalIterator{contract: _GatewayEVMZEVMTest.contract, event: "Withdrawal", logs: logs, sub: sub}, nil } -// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// WatchWithdrawal is a free log subscription operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayEVMZEVMTestWithdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} @@ -2074,9 +2075,9 @@ func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) WatchWithdrawal(opts *bin }), nil } -// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// ParseWithdrawal is a log parse operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayEVMZEVMTest *GatewayEVMZEVMTestFilterer) ParseWithdrawal(log types.Log) (*GatewayEVMZEVMTestWithdrawal, error) { event := new(GatewayEVMZEVMTestWithdrawal) if err := _GatewayEVMZEVMTest.contract.UnpackLog(event, "Withdrawal", log); err != nil { diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index d90a14c0..0a91e131 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -38,8 +38,8 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_wzeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wzeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. @@ -302,6 +302,37 @@ func (_GatewayZEVM *GatewayZEVMCallerSession) ProxiableUUID() ([32]byte, error) return _GatewayZEVM.Contract.ProxiableUUID(&_GatewayZEVM.CallOpts) } +// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// +// Solidity: function wzeta() view returns(address) +func (_GatewayZEVM *GatewayZEVMCaller) Wzeta(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _GatewayZEVM.contract.Call(opts, &out, "wzeta") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// +// Solidity: function wzeta() view returns(address) +func (_GatewayZEVM *GatewayZEVMSession) Wzeta() (common.Address, error) { + return _GatewayZEVM.Contract.Wzeta(&_GatewayZEVM.CallOpts) +} + +// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// +// Solidity: function wzeta() view returns(address) +func (_GatewayZEVM *GatewayZEVMCallerSession) Wzeta() (common.Address, error) { + return _GatewayZEVM.Contract.Wzeta(&_GatewayZEVM.CallOpts) +} + // Call is a paid mutator transaction binding the contract method 0x0ac7c44c. // // Solidity: function call(bytes receiver, bytes message) returns() @@ -386,25 +417,25 @@ func (_GatewayZEVM *GatewayZEVMTransactorSession) Execute(context ZContext, zrc2 return _GatewayZEVM.Contract.Execute(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) } -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize() returns() -func (_GatewayZEVM *GatewayZEVMTransactor) Initialize(opts *bind.TransactOpts) (*types.Transaction, error) { - return _GatewayZEVM.contract.Transact(opts, "initialize") +// Solidity: function initialize(address _wzeta) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Initialize(opts *bind.TransactOpts, _wzeta common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "initialize", _wzeta) } -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize() returns() -func (_GatewayZEVM *GatewayZEVMSession) Initialize() (*types.Transaction, error) { - return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts) +// Solidity: function initialize(address _wzeta) returns() +func (_GatewayZEVM *GatewayZEVMSession) Initialize(_wzeta common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _wzeta) } -// Initialize is a paid mutator transaction binding the contract method 0x8129fc1c. +// Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize() returns() -func (_GatewayZEVM *GatewayZEVMTransactorSession) Initialize() (*types.Transaction, error) { - return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts) +// Solidity: function initialize(address _wzeta) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Initialize(_wzeta common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _wzeta) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. @@ -512,25 +543,67 @@ func (_GatewayZEVM *GatewayZEVMTransactorSession) Withdraw(receiver []byte, amou return _GatewayZEVM.Contract.Withdraw(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20) } -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// Withdraw0 is a paid mutator transaction binding the contract method 0x2e1a7d4d. +// +// Solidity: function withdraw(uint256 amount) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Withdraw0(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "withdraw0", amount) +} + +// Withdraw0 is a paid mutator transaction binding the contract method 0x2e1a7d4d. +// +// Solidity: function withdraw(uint256 amount) returns() +func (_GatewayZEVM *GatewayZEVMSession) Withdraw0(amount *big.Int) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Withdraw0(&_GatewayZEVM.TransactOpts, amount) +} + +// Withdraw0 is a paid mutator transaction binding the contract method 0x2e1a7d4d. +// +// Solidity: function withdraw(uint256 amount) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Withdraw0(amount *big.Int) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Withdraw0(&_GatewayZEVM.TransactOpts, amount) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x267e75a0. +// +// Solidity: function withdrawAndCall(uint256 amount, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) WithdrawAndCall(opts *bind.TransactOpts, amount *big.Int, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "withdrawAndCall", amount, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x267e75a0. +// +// Solidity: function withdrawAndCall(uint256 amount, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) WithdrawAndCall(amount *big.Int, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, amount, message) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x267e75a0. +// +// Solidity: function withdrawAndCall(uint256 amount, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) WithdrawAndCall(amount *big.Int, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, amount, message) +} + +// WithdrawAndCall0 is a paid mutator transaction binding the contract method 0x7993c1e0. // // Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMTransactor) WithdrawAndCall(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.contract.Transact(opts, "withdrawAndCall", receiver, amount, zrc20, message) +func (_GatewayZEVM *GatewayZEVMTransactor) WithdrawAndCall0(opts *bind.TransactOpts, receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "withdrawAndCall0", receiver, amount, zrc20, message) } -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// WithdrawAndCall0 is a paid mutator transaction binding the contract method 0x7993c1e0. // // Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +func (_GatewayZEVM *GatewayZEVMSession) WithdrawAndCall0(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall0(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) } -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x7993c1e0. +// WithdrawAndCall0 is a paid mutator transaction binding the contract method 0x7993c1e0. // // Solidity: function withdrawAndCall(bytes receiver, uint256 amount, address zrc20, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMTransactorSession) WithdrawAndCall(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.Contract.WithdrawAndCall(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) +func (_GatewayZEVM *GatewayZEVMTransactorSession) WithdrawAndCall0(receiver []byte, amount *big.Int, zrc20 common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.WithdrawAndCall0(&_GatewayZEVM.TransactOpts, receiver, amount, zrc20, message) } // GatewayZEVMAdminChangedIterator is returned from FilterAdminChanged and is used to iterate over the raw logs and unpacked data for AdminChanged events raised by the GatewayZEVM contract. @@ -1459,6 +1532,7 @@ func (it *GatewayZEVMWithdrawalIterator) Close() error { // GatewayZEVMWithdrawal represents a Withdrawal event raised by the GatewayZEVM contract. type GatewayZEVMWithdrawal struct { From common.Address + Zrc20 common.Address To []byte Value *big.Int Gasfee *big.Int @@ -1467,9 +1541,9 @@ type GatewayZEVMWithdrawal struct { Raw types.Log // Blockchain specific contextual infos } -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayZEVM *GatewayZEVMFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*GatewayZEVMWithdrawalIterator, error) { var fromRule []interface{} @@ -1484,9 +1558,9 @@ func (_GatewayZEVM *GatewayZEVMFilterer) FilterWithdrawal(opts *bind.FilterOpts, return &GatewayZEVMWithdrawalIterator{contract: _GatewayZEVM.contract, event: "Withdrawal", logs: logs, sub: sub}, nil } -// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// WatchWithdrawal is a free log subscription operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayZEVM *GatewayZEVMFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *GatewayZEVMWithdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} @@ -1526,9 +1600,9 @@ func (_GatewayZEVM *GatewayZEVMFilterer) WatchWithdrawal(opts *bind.WatchOpts, s }), nil } -// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// ParseWithdrawal is a log parse operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_GatewayZEVM *GatewayZEVMFilterer) ParseWithdrawal(log types.Log) (*GatewayZEVMWithdrawal, error) { event := new(GatewayZEVMWithdrawal) if err := _GatewayZEVM.contract.UnpackLog(event, "Withdrawal", log); err != nil { diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go index dde8fa8c..1308aa3c 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go @@ -31,7 +31,7 @@ var ( // IGatewayZEVMErrorsMetaData contains all meta data concerning the IGatewayZEVMErrors contract. var IGatewayZEVMErrorsMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"}]", + ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"}]", } // IGatewayZEVMErrorsABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go index 2ace4e35..0b128fce 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go +++ b/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go @@ -31,7 +31,7 @@ var ( // IGatewayZEVMEventsMetaData contains all meta data concerning the IGatewayZEVMEvents contract. var IGatewayZEVMEventsMetaData = &bind.MetaData{ - ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"}]", + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"}]", } // IGatewayZEVMEventsABI is the input ABI used to generate the binding from. @@ -396,6 +396,7 @@ func (it *IGatewayZEVMEventsWithdrawalIterator) Close() error { // IGatewayZEVMEventsWithdrawal represents a Withdrawal event raised by the IGatewayZEVMEvents contract. type IGatewayZEVMEventsWithdrawal struct { From common.Address + Zrc20 common.Address To []byte Value *big.Int Gasfee *big.Int @@ -404,9 +405,9 @@ type IGatewayZEVMEventsWithdrawal struct { Raw types.Log // Blockchain specific contextual infos } -// FilterWithdrawal is a free log retrieval operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// FilterWithdrawal is a free log retrieval operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) FilterWithdrawal(opts *bind.FilterOpts, from []common.Address) (*IGatewayZEVMEventsWithdrawalIterator, error) { var fromRule []interface{} @@ -421,9 +422,9 @@ func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) FilterWithdrawal(opts *bi return &IGatewayZEVMEventsWithdrawalIterator{contract: _IGatewayZEVMEvents.contract, event: "Withdrawal", logs: logs, sub: sub}, nil } -// WatchWithdrawal is a free log subscription operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// WatchWithdrawal is a free log subscription operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) WatchWithdrawal(opts *bind.WatchOpts, sink chan<- *IGatewayZEVMEventsWithdrawal, from []common.Address) (event.Subscription, error) { var fromRule []interface{} @@ -463,9 +464,9 @@ func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) WatchWithdrawal(opts *bin }), nil } -// ParseWithdrawal is a log parse operation binding the contract event 0x1866ad2994816c79f4103e1eddacc7b085eb7c635205243a28940be69b01536d. +// ParseWithdrawal is a log parse operation binding the contract event 0x2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716. // -// Solidity: event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) +// Solidity: event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message) func (_IGatewayZEVMEvents *IGatewayZEVMEventsFilterer) ParseWithdrawal(log types.Log) (*IGatewayZEVMEventsWithdrawal, error) { event := new(IGatewayZEVMEventsWithdrawal) if err := _IGatewayZEVMEvents.contract.UnpackLog(event, "Withdrawal", log); err != nil { diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 0edd4100..dec285be 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/scripts/worker.ts b/scripts/worker.ts index aaf749a9..ddea9189 100644 --- a/scripts/worker.ts +++ b/scripts/worker.ts @@ -131,11 +131,11 @@ export const startWorker = async () => { await executeTx.wait(); }); - // event Withdrawal(address indexed from, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); + // event Withdrawal(address indexed from, address zrc20, bytes to, uint256 value, uint256 gasfee, uint256 protocolFlatFee, bytes message); systemContracts.gatewayZEVM.on("Withdrawal", async (...args: Array) => { console.log("Worker: Withdrawal event on GatewayZEVM."); const receiver = args[1]; - const message = args[5]; + const message = args[6]; if (message != "0x") { console.log("Worker: Calling ReceiverEVM through GatewayEVM..."); const executeTx = await systemContracts.gatewayEVM.execute(receiver, message, { value: 0 }); diff --git a/test/fuzz/ERC20CustodyNewEchidnaTest.sol b/test/fuzz/ERC20CustodyNewEchidnaTest.sol index 079334df..ae46ace7 100644 --- a/test/fuzz/ERC20CustodyNewEchidnaTest.sol +++ b/test/fuzz/ERC20CustodyNewEchidnaTest.sol @@ -13,7 +13,7 @@ contract ERC20CustodyNewEchidnaTest is ERC20CustodyNew { GatewayEVM testGateway = new GatewayEVM(); constructor() ERC20CustodyNew(address(testGateway)) { - testGateway.initialize(echidnaCaller); + testGateway.initialize(echidnaCaller, address(0x123)); testERC20 = new TestERC20("test", "TEST"); testGateway.setCustody(address(this)); } diff --git a/test/fuzz/GatewayEVMEchidnaTest.sol b/test/fuzz/GatewayEVMEchidnaTest.sol index fda16cbe..f1fefa4d 100644 --- a/test/fuzz/GatewayEVMEchidnaTest.sol +++ b/test/fuzz/GatewayEVMEchidnaTest.sol @@ -11,7 +11,7 @@ contract GatewayEVMEchidnaTest is GatewayEVM { address public echidnaCaller = msg.sender; constructor() { - initialize(echidnaCaller); + initialize(echidnaCaller, address(0x123)); testERC20 = new TestERC20("test", "TEST"); custody = address(new ERC20CustodyNew(address(this))); } diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 1fef7d6e..741c353c 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -1,6 +1,6 @@ import { AddressZero } from "@ethersproject/constants"; import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; -import { SystemContract, ZRC20 } from "@typechain-types"; +import { SystemContract, ZRC20, WETH9 } from "@typechain-types"; import { expect } from "chai"; import { Contract } from "ethers"; import { parseEther } from "ethers/lib/utils"; @@ -33,8 +33,10 @@ describe("GatewayEVM GatewayZEVM integration", function () { const GatewayEVM = await ethers.getContractFactory("GatewayEVM"); const Custody = await ethers.getContractFactory("ERC20CustodyNew"); const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); + const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9"); // Deploy the contracts + const zetaTokenContract = (await WZETAFactory.deploy()) as WETH9; const zeta = await TestERC20.deploy("Zeta", "ZETA"); token = await TestERC20.deploy("Test Token", "TTK"); receiverEVM = await ReceiverEVM.deploy(); @@ -85,7 +87,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { await ZRC20Contract.connect(fungibleModuleSigner).deposit(ownerZEVM.address, parseEther("100")); const GatewayZEVM = await ethers.getContractFactory("GatewayZEVM"); - gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [], { + gatewayZEVM = await upgrades.deployProxy(GatewayZEVM, [zetaTokenContract.address], { initializer: "initialize", kind: "uups", }); @@ -141,13 +143,13 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); const callTx = await gatewayZEVM - .connect(ownerZEVM) - .withdrawAndCall(receiverEVM.address, parseEther("1"), ZRC20Contract.address, message); + .connect(ownerZEVM)["withdrawAndCall(bytes,uint256,address,bytes)"](receiverEVM.address, parseEther("1"), ZRC20Contract.address, message); await expect(callTx) .to.emit(gatewayZEVM, "Withdrawal") .withArgs( ethers.utils.getAddress(ownerZEVM.address), + ethers.utils.getAddress(ZRC20Contract.address), receiverEVM.address.toLowerCase(), parseEther("1"), 0, @@ -158,7 +160,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Get message from events const callTxReceipt = await callTx.wait(); const callEvent = callTxReceipt.events.filter((e) => e.event == "Withdrawal")[0]; - const callMessage = callEvent.args[5]; + const callMessage = callEvent.args[6]; // Call execute on evm const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); @@ -217,6 +219,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { .to.emit(gatewayZEVM, "Withdrawal") .withArgs( ethers.utils.getAddress(senderZEVM.address), + ethers.utils.getAddress(ZRC20Contract.address), receiverEVM.address.toLowerCase(), parseEther("1"), 0, @@ -225,7 +228,7 @@ describe("GatewayEVM GatewayZEVM integration", function () { ); const callEvent = callTxReceipt.events.filter((e) => e.event == "Withdrawal")[0]; - const callMessage = callEvent.args[5]; + const callMessage = callEvent.args[6]; // Call execute on evm const executeTx = await gatewayEVM.execute(receiverEVM.address, callMessage, { value: value }); diff --git a/test/prototypes/GatewayZEVM.spec.ts b/test/prototypes/GatewayZEVM.spec.ts index f215e762..43055791 100644 --- a/test/prototypes/GatewayZEVM.spec.ts +++ b/test/prototypes/GatewayZEVM.spec.ts @@ -33,9 +33,11 @@ describe("GatewayZEVM", function () { const SystemContractFactory = await ethers.getContractFactory("SystemContractMock"); systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; + const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9"); + const zetaTokenContract = (await WZETAFactory.deploy()); const Gateway = await ethers.getContractFactory("GatewayZEVM"); - gateway = await upgrades.deployProxy(Gateway, [], { + gateway = await upgrades.deployProxy(Gateway, [zetaTokenContract.address], { initializer: "initialize", kind: "uups", }); @@ -67,7 +69,7 @@ describe("GatewayZEVM", function () { it("should withdraw zrc20 and emit event", async function () { const tx = await gateway .connect(owner) - .withdraw(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); + ["withdraw(bytes,uint256,address)"](ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); @@ -76,6 +78,7 @@ describe("GatewayZEVM", function () { .to.emit(gateway, "Withdrawal") .withArgs( ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(ZRC20Contract.address), addrs[0].address.toLowerCase(), parseEther("1"), 0, @@ -91,7 +94,7 @@ describe("GatewayZEVM", function () { const tx = await gateway .connect(owner) - .withdrawAndCall(ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); + ["withdrawAndCall(bytes,uint256,address,bytes)"](ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); @@ -100,6 +103,7 @@ describe("GatewayZEVM", function () { .to.emit(gateway, "Withdrawal") .withArgs( ethers.utils.getAddress(owner.address), + ethers.utils.getAddress(ZRC20Contract.address), addrs[0].address.toLowerCase(), parseEther("1"), 0, diff --git a/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts index a887755e..ab262892 100644 --- a/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts +++ b/typechain-types/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest.ts @@ -200,7 +200,7 @@ export interface GatewayEVMZEVMTestInterface extends utils.Interface { "ReceivedNoParams(address)": EventFragment; "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)": EventFragment; "log(string)": EventFragment; "log_address(address)": EventFragment; "log_array(uint256[])": EventFragment; @@ -387,6 +387,7 @@ export type ReceivedPayableEventFilter = TypedEventFilter; export interface WithdrawalEventObject { from: string; + zrc20: string; to: string; value: BigNumber; gasfee: BigNumber; @@ -394,7 +395,7 @@ export interface WithdrawalEventObject { message: string; } export type WithdrawalEvent = TypedEvent< - [string, string, BigNumber, BigNumber, BigNumber, string], + [string, string, string, BigNumber, BigNumber, BigNumber, string], WithdrawalEventObject >; @@ -889,8 +890,9 @@ export interface GatewayEVMZEVMTest extends BaseContract { flag?: null ): ReceivedPayableEventFilter; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)"( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, @@ -899,6 +901,7 @@ export interface GatewayEVMZEVMTest extends BaseContract { ): WithdrawalEventFilter; Withdrawal( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts index a9dde1e5..b972f4d6 100644 --- a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -47,7 +47,7 @@ export interface GatewayZEVMInterface extends utils.Interface { "deposit(address,uint256,address)": FunctionFragment; "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; "execute((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; - "initialize()": FunctionFragment; + "initialize(address)": FunctionFragment; "owner()": FunctionFragment; "proxiableUUID()": FunctionFragment; "renounceOwnership()": FunctionFragment; @@ -55,7 +55,10 @@ export interface GatewayZEVMInterface extends utils.Interface { "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; "withdraw(bytes,uint256,address)": FunctionFragment; + "withdraw(uint256)": FunctionFragment; + "withdrawAndCall(uint256,bytes)": FunctionFragment; "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; + "wzeta()": FunctionFragment; }; getFunction( @@ -72,8 +75,11 @@ export interface GatewayZEVMInterface extends utils.Interface { | "transferOwnership" | "upgradeTo" | "upgradeToAndCall" - | "withdraw" - | "withdrawAndCall" + | "withdraw(bytes,uint256,address)" + | "withdraw(uint256)" + | "withdrawAndCall(uint256,bytes)" + | "withdrawAndCall(bytes,uint256,address,bytes)" + | "wzeta" ): FunctionFragment; encodeFunctionData( @@ -114,7 +120,7 @@ export interface GatewayZEVMInterface extends utils.Interface { ): string; encodeFunctionData( functionFragment: "initialize", - values?: undefined + values: [PromiseOrValue] ): string; encodeFunctionData(functionFragment: "owner", values?: undefined): string; encodeFunctionData( @@ -138,7 +144,7 @@ export interface GatewayZEVMInterface extends utils.Interface { values: [PromiseOrValue, PromiseOrValue] ): string; encodeFunctionData( - functionFragment: "withdraw", + functionFragment: "withdraw(bytes,uint256,address)", values: [ PromiseOrValue, PromiseOrValue, @@ -146,7 +152,15 @@ export interface GatewayZEVMInterface extends utils.Interface { ] ): string; encodeFunctionData( - functionFragment: "withdrawAndCall", + functionFragment: "withdraw(uint256)", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall(uint256,bytes)", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall(bytes,uint256,address,bytes)", values: [ PromiseOrValue, PromiseOrValue, @@ -154,6 +168,7 @@ export interface GatewayZEVMInterface extends utils.Interface { PromiseOrValue ] ): string; + encodeFunctionData(functionFragment: "wzeta", values?: undefined): string; decodeFunctionResult( functionFragment: "FUNGIBLE_MODULE_ADDRESS", @@ -185,11 +200,23 @@ export interface GatewayZEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; decodeFunctionResult( - functionFragment: "withdrawAndCall", + functionFragment: "withdraw(bytes,uint256,address)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "withdraw(uint256)", data: BytesLike ): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall(uint256,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall(bytes,uint256,address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "wzeta", data: BytesLike): Result; events: { "AdminChanged(address,address)": EventFragment; @@ -198,7 +225,7 @@ export interface GatewayZEVMInterface extends utils.Interface { "Initialized(uint8)": EventFragment; "OwnershipTransferred(address,address)": EventFragment; "Upgraded(address)": EventFragment; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "AdminChanged"): EventFragment; @@ -268,6 +295,7 @@ export type UpgradedEventFilter = TypedEventFilter; export interface WithdrawalEventObject { from: string; + zrc20: string; to: string; value: BigNumber; gasfee: BigNumber; @@ -275,7 +303,7 @@ export interface WithdrawalEventObject { message: string; } export type WithdrawalEvent = TypedEvent< - [string, string, BigNumber, BigNumber, BigNumber, string], + [string, string, string, BigNumber, BigNumber, BigNumber, string], WithdrawalEventObject >; @@ -342,6 +370,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( + _wzeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -369,20 +398,33 @@ export interface GatewayZEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - withdraw( + "withdraw(bytes,uint256,address)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - withdrawAndCall( + "withdraw(uint256)"( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(uint256,bytes)"( + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(bytes,uint256,address,bytes)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, message: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + wzeta(overrides?: CallOverrides): Promise<[string]>; }; FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; @@ -419,6 +461,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( + _wzeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -446,14 +489,25 @@ export interface GatewayZEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - withdraw( + "withdraw(bytes,uint256,address)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - withdrawAndCall( + "withdraw(uint256)"( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(uint256,bytes)"( + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(bytes,uint256,address,bytes)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, @@ -461,6 +515,8 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + wzeta(overrides?: CallOverrides): Promise; + callStatic: { FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; @@ -495,7 +551,10 @@ export interface GatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; - initialize(overrides?: CallOverrides): Promise; + initialize( + _wzeta: PromiseOrValue, + overrides?: CallOverrides + ): Promise; owner(overrides?: CallOverrides): Promise; @@ -519,20 +578,33 @@ export interface GatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; - withdraw( + "withdraw(bytes,uint256,address)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, overrides?: CallOverrides ): Promise; - withdrawAndCall( + "withdraw(uint256)"( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "withdrawAndCall(uint256,bytes)"( + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "withdrawAndCall(bytes,uint256,address,bytes)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, message: PromiseOrValue, overrides?: CallOverrides ): Promise; + + wzeta(overrides?: CallOverrides): Promise; }; filters: { @@ -582,8 +654,9 @@ export interface GatewayZEVM extends BaseContract { implementation?: PromiseOrValue | null ): UpgradedEventFilter; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)"( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, @@ -592,6 +665,7 @@ export interface GatewayZEVM extends BaseContract { ): WithdrawalEventFilter; Withdrawal( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, @@ -635,6 +709,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( + _wzeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -662,20 +737,33 @@ export interface GatewayZEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - withdraw( + "withdraw(bytes,uint256,address)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - withdrawAndCall( + "withdraw(uint256)"( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(uint256,bytes)"( + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(bytes,uint256,address,bytes)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, message: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + wzeta(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -715,6 +803,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( + _wzeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -742,19 +831,32 @@ export interface GatewayZEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - withdraw( + "withdraw(bytes,uint256,address)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - withdrawAndCall( + "withdraw(uint256)"( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(uint256,bytes)"( + amount: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "withdrawAndCall(bytes,uint256,address,bytes)"( receiver: PromiseOrValue, amount: PromiseOrValue, zrc20: PromiseOrValue, message: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; + + wzeta(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts index 21a7ccd5..829208d9 100644 --- a/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts +++ b/typechain-types/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents.ts @@ -17,7 +17,7 @@ export interface IGatewayZEVMEventsInterface extends utils.Interface { events: { "Call(address,bytes,bytes)": EventFragment; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)": EventFragment; }; getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; @@ -35,6 +35,7 @@ export type CallEventFilter = TypedEventFilter; export interface WithdrawalEventObject { from: string; + zrc20: string; to: string; value: BigNumber; gasfee: BigNumber; @@ -42,7 +43,7 @@ export interface WithdrawalEventObject { message: string; } export type WithdrawalEvent = TypedEvent< - [string, string, BigNumber, BigNumber, BigNumber, string], + [string, string, string, BigNumber, BigNumber, BigNumber, string], WithdrawalEventObject >; @@ -90,8 +91,9 @@ export interface IGatewayZEVMEvents extends BaseContract { message?: null ): CallEventFilter; - "Withdrawal(address,bytes,uint256,uint256,uint256,bytes)"( + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)"( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, @@ -100,6 +102,7 @@ export interface IGatewayZEVMEvents extends BaseContract { ): WithdrawalEventFilter; Withdrawal( from?: PromiseOrValue | null, + zrc20?: null, to?: null, value?: null, gasfee?: null, diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index d435ca66..38d4fde3 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -35,6 +35,11 @@ const _abi = [ name: "ExecutionFailed", type: "error", }, + { + inputs: [], + name: "FailedZetaSent", + type: "error", + }, { inputs: [], name: "GasFeeTransferFailed", @@ -60,6 +65,11 @@ const _abi = [ name: "InvalidTarget", type: "error", }, + { + inputs: [], + name: "WZETATransferFailed", + type: "error", + }, { inputs: [], name: "WithdrawalFailed", @@ -344,6 +354,12 @@ const _abi = [ name: "from", type: "address", }, + { + indexed: false, + internalType: "address", + name: "zrc20", + type: "address", + }, { indexed: false, internalType: "bytes", @@ -963,7 +979,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index 2e4bc8ac..b862dc50 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -20,6 +20,11 @@ const _abi = [ name: "CallerIsNotFungibleModule", type: "error", }, + { + inputs: [], + name: "FailedZetaSent", + type: "error", + }, { inputs: [], name: "GasFeeTransferFailed", @@ -35,6 +40,11 @@ const _abi = [ name: "InvalidTarget", type: "error", }, + { + inputs: [], + name: "WZETATransferFailed", + type: "error", + }, { inputs: [], name: "WithdrawalFailed", @@ -161,6 +171,12 @@ const _abi = [ name: "from", type: "address", }, + { + indexed: false, + internalType: "address", + name: "zrc20", + type: "address", + }, { indexed: false, internalType: "bytes", @@ -350,7 +366,13 @@ const _abi = [ type: "function", }, { - inputs: [], + inputs: [ + { + internalType: "address", + name: "_wzeta", + type: "address", + }, + ], name: "initialize", outputs: [], stateMutability: "nonpayable", @@ -456,6 +478,37 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -484,10 +537,23 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [], + name: "wzeta", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index 3742ffc2..577b6ab6 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts index f912a171..9240eeb0 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory.ts @@ -15,6 +15,11 @@ const _abi = [ name: "CallerIsNotFungibleModule", type: "error", }, + { + inputs: [], + name: "FailedZetaSent", + type: "error", + }, { inputs: [], name: "GasFeeTransferFailed", @@ -30,6 +35,11 @@ const _abi = [ name: "InvalidTarget", type: "error", }, + { + inputs: [], + name: "WZETATransferFailed", + type: "error", + }, { inputs: [], name: "WithdrawalFailed", diff --git a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts index 1ad08445..2c3a8834 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory.ts @@ -44,6 +44,12 @@ const _abi = [ name: "from", type: "address", }, + { + indexed: false, + internalType: "address", + name: "zrc20", + type: "address", + }, { indexed: false, internalType: "bytes", From f3c9a0b3689a76fc76a6ac28ff1a320929304ccf Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 10 Jul 2024 03:32:12 +0200 Subject: [PATCH 73/86] deposit and call gateway zevm --- contracts/prototypes/zevm/GatewayZEVM.sol | 18 +++++ .../gatewayevmzevmtest.go | 2 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 43 ++++++++--- test/prototypes/GatewayIntegration.spec.ts | 10 ++- test/prototypes/GatewayZEVM.spec.ts | 17 +++-- .../contracts/prototypes/zevm/GatewayZEVM.ts | 71 ++++++++++++++++--- .../GatewayEVMZEVMTest__factory.ts | 2 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 47 +++++++++++- 8 files changed, 182 insertions(+), 28 deletions(-) diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 6b8f872b..2d01dcc4 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -125,4 +125,22 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O IZRC20(zrc20).deposit(target, amount); zContract(target).onCrossChainCall(context, zrc20, amount, message); } + + // Deposit zeta and call user specified contract on ZEVM + // TODO: Finalize access control + // https://github.com/zeta-chain/protocol-contracts/issues/204 + function depositAndCall( + zContext calldata context, + uint256 amount, + address target, + bytes calldata message + ) external { + if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); + if (target == FUNGIBLE_MODULE_ADDRESS || target == address(this)) revert InvalidTarget(); + + if (!IWETH9(wzeta).transferFrom(msg.sender, address(this), amount)) revert WZETATransferFailed(); + IWETH9(wzeta).withdraw(amount); + (bool sent, ) = target.call{value: amount}(""); + zContract(target).onCrossChainCall(context, wzeta, amount, message); + } } diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index a5e7dd0e..5cd9461e 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 0a91e131..87fa11ad 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -38,8 +38,8 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_wzeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wzeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_wzeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wzeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. @@ -375,25 +375,46 @@ func (_GatewayZEVM *GatewayZEVMTransactorSession) Deposit(zrc20 common.Address, return _GatewayZEVM.Contract.Deposit(&_GatewayZEVM.TransactOpts, zrc20, amount, target) } -// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// DepositAndCall is a paid mutator transaction binding the contract method 0x21501a95. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) DepositAndCall(opts *bind.TransactOpts, context ZContext, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "depositAndCall", context, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x21501a95. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMSession) DepositAndCall(context ZContext, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, amount, target, message) +} + +// DepositAndCall is a paid mutator transaction binding the contract method 0x21501a95. +// +// Solidity: function depositAndCall((bytes,address,uint256) context, uint256 amount, address target, bytes message) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) DepositAndCall(context ZContext, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, amount, target, message) +} + +// DepositAndCall0 is a paid mutator transaction binding the contract method 0xc39aca37. // // Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMTransactor) DepositAndCall(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.contract.Transact(opts, "depositAndCall", context, zrc20, amount, target, message) +func (_GatewayZEVM *GatewayZEVMTransactor) DepositAndCall0(opts *bind.TransactOpts, context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "depositAndCall0", context, zrc20, amount, target, message) } -// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// DepositAndCall0 is a paid mutator transaction binding the contract method 0xc39aca37. // // Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +func (_GatewayZEVM *GatewayZEVMSession) DepositAndCall0(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall0(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) } -// DepositAndCall is a paid mutator transaction binding the contract method 0xc39aca37. +// DepositAndCall0 is a paid mutator transaction binding the contract method 0xc39aca37. // // Solidity: function depositAndCall((bytes,address,uint256) context, address zrc20, uint256 amount, address target, bytes message) returns() -func (_GatewayZEVM *GatewayZEVMTransactorSession) DepositAndCall(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { - return _GatewayZEVM.Contract.DepositAndCall(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) +func (_GatewayZEVM *GatewayZEVMTransactorSession) DepositAndCall0(context ZContext, zrc20 common.Address, amount *big.Int, target common.Address, message []byte) (*types.Transaction, error) { + return _GatewayZEVM.Contract.DepositAndCall0(&_GatewayZEVM.TransactOpts, context, zrc20, amount, target, message) } // Execute is a paid mutator transaction binding the contract method 0xbcf7f32b. diff --git a/test/prototypes/GatewayIntegration.spec.ts b/test/prototypes/GatewayIntegration.spec.ts index 741c353c..faf5246a 100644 --- a/test/prototypes/GatewayIntegration.spec.ts +++ b/test/prototypes/GatewayIntegration.spec.ts @@ -1,6 +1,6 @@ import { AddressZero } from "@ethersproject/constants"; import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers"; -import { SystemContract, ZRC20, WETH9 } from "@typechain-types"; +import { SystemContract, WETH9, ZRC20 } from "@typechain-types"; import { expect } from "chai"; import { Contract } from "ethers"; import { parseEther } from "ethers/lib/utils"; @@ -143,7 +143,13 @@ describe("GatewayEVM GatewayZEVM integration", function () { // Encode the function call data and call on zevm const message = receiverEVM.interface.encodeFunctionData("receivePayable", [str, num, flag]); const callTx = await gatewayZEVM - .connect(ownerZEVM)["withdrawAndCall(bytes,uint256,address,bytes)"](receiverEVM.address, parseEther("1"), ZRC20Contract.address, message); + .connect(ownerZEVM) + ["withdrawAndCall(bytes,uint256,address,bytes)"]( + receiverEVM.address, + parseEther("1"), + ZRC20Contract.address, + message + ); await expect(callTx) .to.emit(gatewayZEVM, "Withdrawal") diff --git a/test/prototypes/GatewayZEVM.spec.ts b/test/prototypes/GatewayZEVM.spec.ts index 43055791..e460fc6f 100644 --- a/test/prototypes/GatewayZEVM.spec.ts +++ b/test/prototypes/GatewayZEVM.spec.ts @@ -35,7 +35,7 @@ describe("GatewayZEVM", function () { systemContract = (await SystemContractFactory.deploy(AddressZero, AddressZero, AddressZero)) as SystemContract; const WZETAFactory = await ethers.getContractFactory("contracts/zevm/WZETA.sol:WETH9"); - const zetaTokenContract = (await WZETAFactory.deploy()); + const zetaTokenContract = await WZETAFactory.deploy(); const Gateway = await ethers.getContractFactory("GatewayZEVM"); gateway = await upgrades.deployProxy(Gateway, [zetaTokenContract.address], { initializer: "initialize", @@ -69,7 +69,11 @@ describe("GatewayZEVM", function () { it("should withdraw zrc20 and emit event", async function () { const tx = await gateway .connect(owner) - ["withdraw(bytes,uint256,address)"](ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address); + ["withdraw(bytes,uint256,address)"]( + ethers.utils.arrayify(addrs[0].address), + parseEther("1"), + ZRC20Contract.address + ); const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); @@ -94,7 +98,12 @@ describe("GatewayZEVM", function () { const tx = await gateway .connect(owner) - ["withdrawAndCall(bytes,uint256,address,bytes)"](ethers.utils.arrayify(addrs[0].address), parseEther("1"), ZRC20Contract.address, message); + ["withdrawAndCall(bytes,uint256,address,bytes)"]( + ethers.utils.arrayify(addrs[0].address), + parseEther("1"), + ZRC20Contract.address, + message + ); const balanceOfAfterWithdrawal = (await ZRC20Contract.balanceOf(owner.address)) as BigNumber; expect(balanceOfAfterWithdrawal).to.equal(parseEther("99")); @@ -165,7 +174,7 @@ describe("GatewayZEVM", function () { const message = ethers.utils.defaultAbiCoder.encode(["string"], ["hello"]); const tx = await gateway .connect(fungibleModuleSigner) - .depositAndCall( + ["depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"]( [gateway.address, fungibleModuleSigner.address, 1], ZRC20Contract.address, parseEther("1"), diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts index b972f4d6..d24a0e4f 100644 --- a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -45,6 +45,7 @@ export interface GatewayZEVMInterface extends utils.Interface { "FUNGIBLE_MODULE_ADDRESS()": FunctionFragment; "call(bytes,bytes)": FunctionFragment; "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall((bytes,address,uint256),uint256,address,bytes)": FunctionFragment; "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; "execute((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; "initialize(address)": FunctionFragment; @@ -66,7 +67,8 @@ export interface GatewayZEVMInterface extends utils.Interface { | "FUNGIBLE_MODULE_ADDRESS" | "call" | "deposit" - | "depositAndCall" + | "depositAndCall((bytes,address,uint256),uint256,address,bytes)" + | "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)" | "execute" | "initialize" | "owner" @@ -99,7 +101,16 @@ export interface GatewayZEVMInterface extends utils.Interface { ] ): string; encodeFunctionData( - functionFragment: "depositAndCall", + functionFragment: "depositAndCall((bytes,address,uint256),uint256,address,bytes)", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)", values: [ ZContextStruct, PromiseOrValue, @@ -177,7 +188,11 @@ export interface GatewayZEVMInterface extends utils.Interface { decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; decodeFunctionResult( - functionFragment: "depositAndCall", + functionFragment: "depositAndCall((bytes,address,uint256),uint256,address,bytes)", + data: BytesLike + ): Result; + decodeFunctionResult( + functionFragment: "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)", data: BytesLike ): Result; decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; @@ -351,7 +366,15 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - depositAndCall( + "depositAndCall((bytes,address,uint256),uint256,address,bytes)"( + context: ZContextStruct, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"( context: ZContextStruct, zrc20: PromiseOrValue, amount: PromiseOrValue, @@ -442,7 +465,15 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - depositAndCall( + "depositAndCall((bytes,address,uint256),uint256,address,bytes)"( + context: ZContextStruct, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"( context: ZContextStruct, zrc20: PromiseOrValue, amount: PromiseOrValue, @@ -533,7 +564,15 @@ export interface GatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; - depositAndCall( + "depositAndCall((bytes,address,uint256),uint256,address,bytes)"( + context: ZContextStruct, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"( context: ZContextStruct, zrc20: PromiseOrValue, amount: PromiseOrValue, @@ -690,7 +729,15 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - depositAndCall( + "depositAndCall((bytes,address,uint256),uint256,address,bytes)"( + context: ZContextStruct, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"( context: ZContextStruct, zrc20: PromiseOrValue, amount: PromiseOrValue, @@ -784,7 +831,15 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - depositAndCall( + "depositAndCall((bytes,address,uint256),uint256,address,bytes)"( + context: ZContextStruct, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)"( context: ZContextStruct, zrc20: PromiseOrValue, amount: PromiseOrValue, diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index 38d4fde3..f471c20e 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -979,7 +979,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index b862dc50..bf4069a8 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -265,6 +265,51 @@ const _abi = [ stateMutability: "nonpayable", type: "function", }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, { inputs: [ { @@ -553,7 +598,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] From 8457ec3e3d7bb723284eebbe595b97d016f53371 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 16 Jul 2024 15:31:36 +0200 Subject: [PATCH 74/86] cleanup --- contracts/prototypes/evm/GatewayEVM.sol | 26 ++++++++++++------- contracts/prototypes/evm/ZetaConnectorNew.sol | 6 +++-- contracts/prototypes/zevm/GatewayZEVM.sol | 14 +++++----- foundry.toml | 1 - lib/openzeppelin-foundry-upgrades | 1 + 5 files changed, 27 insertions(+), 21 deletions(-) create mode 160000 lib/openzeppelin-foundry-upgrades diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 40225252..c030ec01 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -16,18 +16,20 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate address public custody; address public tssAddress; address public zetaConnector; - address public zetaAsset; + address public zeta; constructor() {} - function initialize(address _tssAddress, address _zetaAsset) public initializer { + function initialize(address _tssAddress, address _zeta) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); - if (_tssAddress == address(0)) revert ZeroAddress(); + if (_tssAddress == address(0) || _zeta == address(0)) { + revert ZeroAddress(); + } tssAddress = _tssAddress; - zetaAsset = _zetaAsset; + zeta = _zeta; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -75,8 +77,8 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Transfer any remaining tokens back to the custody/connector contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - address destination = address(custody); - if (token == zetaAsset) { + address destination = address(custody); + if (token == zeta) { destination = address(zetaConnector); } IERC20(token).safeTransfer(address(destination), remainingBalance); @@ -97,12 +99,12 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate emit Deposit(msg.sender, receiver, msg.value, address(0), ""); } - // Deposit ERC20 tokens to custody + // Deposit ERC20 tokens to custody/connector function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zetaAsset) { + if (asset == zeta) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); @@ -120,12 +122,12 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate emit Deposit(msg.sender, receiver, msg.value, address(0), payload); } - // Deposit ERC20 tokens to custody and call an omnichain smart contract + // Deposit ERC20 tokens to custody/connector and call an omnichain smart contract function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zetaAsset) { + if (asset == zeta) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); @@ -140,11 +142,15 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function setCustody(address _custody) external { if (custody != address(0)) revert CustodyInitialized(); + if (_custody == address(0)) revert ZeroAddress(); + custody = _custody; } function setConnector(address _zetaConnector) external { if (zetaConnector != address(0)) revert CustodyInitialized(); + if (_zetaConnector == address(0)) revert ZeroAddress(); + zetaConnector = _zetaConnector; } diff --git a/contracts/prototypes/evm/ZetaConnectorNew.sol b/contracts/prototypes/evm/ZetaConnectorNew.sol index c10d01fc..d7724405 100644 --- a/contracts/prototypes/evm/ZetaConnectorNew.sol +++ b/contracts/prototypes/evm/ZetaConnectorNew.sol @@ -10,8 +10,8 @@ contract ZetaConnectorNew is ReentrancyGuard{ using SafeERC20 for IERC20; error ZeroAddress(); - IGatewayEVM public gateway; - IERC20 public zeta; + IGatewayEVM public immutable gateway; + IERC20 public immutable zeta; event Withdraw(address indexed to, uint256 amount); event WithdrawAndCall(address indexed to, uint256 amount, bytes data); @@ -28,6 +28,7 @@ contract ZetaConnectorNew is ReentrancyGuard{ // TODO: Finalize access control // https://github.com/zeta-chain/protocol-contracts/issues/204 function withdraw(address to, uint256 amount) external nonReentrant { + // TODO: mint? zeta.safeTransfer(to, amount); emit Withdraw(to, amount); @@ -38,6 +39,7 @@ contract ZetaConnectorNew is ReentrancyGuard{ // TODO: Finalize access control // https://github.com/zeta-chain/protocol-contracts/issues/204 function withdrawAndCall(address to, uint256 amount, bytes calldata data) public nonReentrant { + // TODO: mint? // Transfer zeta to the Gateway contract zeta.safeTransfer(address(gateway), amount); diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 2d01dcc4..48fba375 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -24,7 +24,7 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O function initialize(address _wzeta) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); - wzeta = wzeta; + wzeta = _wzeta; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -44,10 +44,10 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O return gasFee; } - function _withdrawZETA(uint256 amount) internal { + function _transferZETA(uint256 amount, address to) internal { if (!IWETH9(wzeta).transferFrom(msg.sender, address(this), amount)) revert WZETATransferFailed(); IWETH9(wzeta).withdraw(amount); - (bool sent, ) = FUNGIBLE_MODULE_ADDRESS.call{value: amount}(""); + (bool sent, ) = to.call{value: amount}(""); if (!sent) revert FailedZetaSent(); } @@ -65,13 +65,13 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O // Withdraw ZETA to external chain function withdraw(uint256 amount) external { - _withdrawZETA(amount); + _transferZETA(amount, FUNGIBLE_MODULE_ADDRESS); emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, ""); } // Withdraw ZETA and call smart contract on external chain function withdrawAndCall(uint256 amount, bytes calldata message) external { - _withdrawZETA(amount); + _transferZETA(amount, FUNGIBLE_MODULE_ADDRESS); emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, message); } @@ -138,9 +138,7 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O if (msg.sender != FUNGIBLE_MODULE_ADDRESS) revert CallerIsNotFungibleModule(); if (target == FUNGIBLE_MODULE_ADDRESS || target == address(this)) revert InvalidTarget(); - if (!IWETH9(wzeta).transferFrom(msg.sender, address(this), amount)) revert WZETATransferFailed(); - IWETH9(wzeta).withdraw(amount); - (bool sent, ) = target.call{value: amount}(""); + _transferZETA(amount, target); zContract(target).onCrossChainCall(context, wzeta, amount, message); } } diff --git a/foundry.toml b/foundry.toml index 937218cb..4f9e3b66 100644 --- a/foundry.toml +++ b/foundry.toml @@ -5,6 +5,5 @@ libs = ['node_modules', 'lib'] test = 'test' cache_path = 'cache_forge' no-match-contract = '.*EchidnaTest$' -auto_detect_solc = true optimizer = true optimizer_runs = 10_000 diff --git a/lib/openzeppelin-foundry-upgrades b/lib/openzeppelin-foundry-upgrades new file mode 160000 index 00000000..4cd15fc5 --- /dev/null +++ b/lib/openzeppelin-foundry-upgrades @@ -0,0 +1 @@ +Subproject commit 4cd15fc50b141c77d8cc9ff8efb44d00e841a299 From 48758248d74ea90db9f7502ac312d306de277377 Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 16 Jul 2024 15:37:40 +0200 Subject: [PATCH 75/86] generate --- .../evm/gatewayevm.sol/gatewayevm.go | 46 +++++++++---------- .../zetaconnectornew.sol/zetaconnectornew.go | 2 +- .../test/gatewayevm.t.sol/gatewayevmtest.go | 2 +- .../gatewayevmzevmtest.go | 2 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 2 +- .../contracts/prototypes/evm/GatewayEVM.ts | 28 +++++------ .../prototypes/evm/GatewayEVM__factory.ts | 6 +-- .../evm/ZetaConnectorNew__factory.ts | 2 +- .../GatewayEVMTest__factory.ts | 2 +- .../GatewayEVMZEVMTest__factory.ts | 2 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 2 +- 11 files changed, 48 insertions(+), 48 deletions(-) diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 2d8e9ef4..f36dfc03 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -31,8 +31,8 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaAsset\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c6134e361008160003960008181610768015281816107f701528181610b2201528181610bb10152610fcd01526134e36000f3fe60806040526004361061011f5760003560e01c80635b112591116100a0578063dda79b7511610064578063dda79b7514610382578063f2fde38b146103ad578063f31e62bf146103d6578063f340fa0114610401578063f45346dc1461041d5761011f565b80635b112591146102c3578063715018a6146102ee5780638c6f037f146103055780638da5cb5b1461032e578063ae7a3a6f146103595761011f565b8063485cc955116100e7578063485cc955146101eb5780634f1ef286146102145780635131ab591461023057806352d1902d1461026d57806357bec62f146102985761011f565b806310188aef146101245780631b8b921d1461014d5780631cff79cd1461017657806329c59b5d146101a65780633659cfe6146101c2575b600080fd5b34801561013057600080fd5b5061014b6004803603810190610146919061244e565b610446565b005b34801561015957600080fd5b50610174600480360381019061016f9190612543565b610512565b005b610190600480360381019061018b9190612543565b61057e565b60405161019d9190612bd6565b60405180910390f35b6101c060048036038101906101bb9190612543565b6105ec565b005b3480156101ce57600080fd5b506101e960048036038101906101e4919061244e565b610766565b005b3480156101f757600080fd5b50610212600480360381019061020d919061247b565b6108ef565b005b61022e600480360381019061022991906125a3565b610b20565b005b34801561023c57600080fd5b50610257600480360381019061025291906124bb565b610c5d565b6040516102649190612bd6565b60405180910390f35b34801561027957600080fd5b50610282610fc9565b60405161028f9190612b97565b60405180910390f35b3480156102a457600080fd5b506102ad611082565b6040516102ba9190612af3565b60405180910390f35b3480156102cf57600080fd5b506102d86110a8565b6040516102e59190612af3565b60405180910390f35b3480156102fa57600080fd5b506103036110ce565b005b34801561031157600080fd5b5061032c60048036038101906103279190612652565b6110e2565b005b34801561033a57600080fd5b50610343611260565b6040516103509190612af3565b60405180910390f35b34801561036557600080fd5b50610380600480360381019061037b919061244e565b61128a565b005b34801561038e57600080fd5b50610397611356565b6040516103a49190612af3565b60405180910390f35b3480156103b957600080fd5b506103d460048036038101906103cf919061244e565b61137c565b005b3480156103e257600080fd5b506103eb611400565b6040516103f89190612af3565b60405180910390f35b61041b6004803603810190610416919061244e565b611426565b005b34801561042957600080fd5b50610444600480360381019061043f91906125ff565b61159a565b005b600073ffffffffffffffffffffffffffffffffffffffff1660cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146104ce576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060cb60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde38484604051610571929190612bb2565b60405180910390a3505050565b6060600061058d858585611712565b90508473ffffffffffffffffffffffffffffffffffffffff167fcaf938de11c367272220bfd1d2baa99ca46665e7bc4d85f00adb51b90fe1fa9f3486866040516105d993929190612e51565b60405180910390a2809150509392505050565b6000341415610627576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163460405161066f90612ade565b60006040518083038185875af1925050503d80600081146106ac576040519150601f19603f3d011682016040523d82523d6000602084013e6106b1565b606091505b505090506000151581151514156106f4576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516107589493929190612dd5565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156107f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ec90612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166108346117c9565b73ffffffffffffffffffffffffffffffffffffffff161461088a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161088190612c75565b60405180910390fd5b61089381611820565b6108ec81600067ffffffffffffffff8111156108b2576108b1613012565b5b6040519080825280601f01601f1916602001820160405280156108e45781602001600182028036833780820191505090505b50600061182b565b50565b60008060019054906101000a900460ff161590508080156109205750600160008054906101000a900460ff1660ff16105b8061094d575061092f306119a8565b15801561094c5750600160008054906101000a900460ff1660ff16145b5b61098c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161098390612cf5565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109c9576001600060016101000a81548160ff0219169083151502179055505b6109d16119cb565b6109d9611a24565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610a40576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8260ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508160cc60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610b1b5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610b129190612bf8565b60405180910390a15b505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610baf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ba690612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610bee6117c9565b73ffffffffffffffffffffffffffffffffffffffff1614610c44576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c3b90612c75565b60405180910390fd5b610c4d82611820565b610c598282600161182b565b5050565b60606000841415610c9a576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610ca48686611a75565b610cda576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610d15929190612b6e565b602060405180830381600087803b158015610d2f57600080fd5b505af1158015610d43573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d6791906126da565b610d9d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610daa868585611712565b9050610db68787611a75565b610dec576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610e279190612af3565b60206040518083038186803b158015610e3f57600080fd5b505afa158015610e53573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e779190612734565b90506000811115610f5257600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168973ffffffffffffffffffffffffffffffffffffffff161415610f255760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b610f5081838b73ffffffffffffffffffffffffffffffffffffffff16611b0d9092919063ffffffff16565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610fb393929190612e51565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614611059576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161105090612cb5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110d6611b93565b6110e06000611c11565b565b600084141561111d576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156111c05760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6111ed3382878773ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8573ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4878787876040516112509493929190612dd5565b60405180910390a3505050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611312576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b611384611b93565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156113f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113eb90612c35565b60405180910390fd5b6113fd81611c11565b50565b60cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000341415611461576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516114a990612ade565b60006040518083038185875af1925050503d80600081146114e6576040519150601f19603f3d011682016040523d82523d6000602084013e6114eb565b606091505b5050905060001515811515141561152e576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600060405161158e929190612e15565b60405180910390a35050565b60008214156115d5576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116785760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6116a53382858573ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48585604051611704929190612e15565b60405180910390a350505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1634868660405161173f929190612aae565b60006040518083038185875af1925050503d806000811461177c576040519150601f19603f3d011682016040523d82523d6000602084013e611781565b606091505b5091509150816117bd576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006117f77f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b611828611b93565b50565b6118577f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611d6a565b60000160009054906101000a900460ff161561187b5761187683611d74565b6119a3565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156118c157600080fd5b505afa9250505080156118f257506040513d601f19601f820116820180604052508101906118ef9190612707565b60015b611931576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161192890612d15565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611996576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161198d90612cd5565b60405180910390fd5b506119a2838383611e2d565b5b505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611a1a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a1190612d95565b60405180910390fd5b611a22611e59565b565b600060019054906101000a900460ff16611a73576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a6a90612d95565b60405180910390fd5b565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611ab3929190612b45565b602060405180830381600087803b158015611acd57600080fd5b505af1158015611ae1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b0591906126da565b905092915050565b611b8e8363a9059cbb60e01b8484604051602401611b2c929190612b6e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b505050565b611b9b611f81565b73ffffffffffffffffffffffffffffffffffffffff16611bb9611260565b73ffffffffffffffffffffffffffffffffffffffff1614611c0f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c0690612d55565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b611d5a846323b872dd60e01b858585604051602401611cf893929190612b0e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b50505050565b6000819050919050565b6000819050919050565b611d7d816119a8565b611dbc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611db390612d35565b60405180910390fd5b80611de97f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611e3683611f89565b600082511180611e435750805b15611e5457611e528383611fd8565b505b505050565b600060019054906101000a900460ff16611ea8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e9f90612d95565b60405180910390fd5b611eb8611eb3611f81565b611c11565b565b6000611f1c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166120059092919063ffffffff16565b9050600081511115611f7c5780806020019051810190611f3c91906126da565b611f7b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f7290612db5565b60405180910390fd5b5b505050565b600033905090565b611f9281611d74565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611ffd83836040518060600160405280602781526020016134876027913961201d565b905092915050565b606061201484846000856120a3565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516120479190612ac7565b600060405180830381855af49150503d8060008114612082576040519150601f19603f3d011682016040523d82523d6000602084013e612087565b606091505b509150915061209886838387612170565b925050509392505050565b6060824710156120e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120df90612c95565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516121119190612ac7565b60006040518083038185875af1925050503d806000811461214e576040519150601f19603f3d011682016040523d82523d6000602084013e612153565b606091505b5091509150612164878383876121e6565b92505050949350505050565b606083156121d3576000835114156121cb5761218b856119a8565b6121ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121c190612d75565b60405180910390fd5b5b8290506121de565b6121dd838361225c565b5b949350505050565b606083156122495760008351141561224157612201856122ac565b612240576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161223790612d75565b60405180910390fd5b5b829050612254565b61225383836122cf565b5b949350505050565b60008251111561226f5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122a39190612c13565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156122e25781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123169190612c13565b60405180910390fd5b600061233261232d84612ea8565b612e83565b90508281526020810184848401111561234e5761234d613050565b5b612359848285612f9f565b509392505050565b6000813590506123708161342a565b92915050565b60008151905061238581613441565b92915050565b60008151905061239a81613458565b92915050565b60008083601f8401126123b6576123b5613046565b5b8235905067ffffffffffffffff8111156123d3576123d2613041565b5b6020830191508360018202830111156123ef576123ee61304b565b5b9250929050565b600082601f83011261240b5761240a613046565b5b813561241b84826020860161231f565b91505092915050565b6000813590506124338161346f565b92915050565b6000815190506124488161346f565b92915050565b6000602082840312156124645761246361305a565b5b600061247284828501612361565b91505092915050565b600080604083850312156124925761249161305a565b5b60006124a085828601612361565b92505060206124b185828601612361565b9150509250929050565b6000806000806000608086880312156124d7576124d661305a565b5b60006124e588828901612361565b95505060206124f688828901612361565b945050604061250788828901612424565b935050606086013567ffffffffffffffff81111561252857612527613055565b5b612534888289016123a0565b92509250509295509295909350565b60008060006040848603121561255c5761255b61305a565b5b600061256a86828701612361565b935050602084013567ffffffffffffffff81111561258b5761258a613055565b5b612597868287016123a0565b92509250509250925092565b600080604083850312156125ba576125b961305a565b5b60006125c885828601612361565b925050602083013567ffffffffffffffff8111156125e9576125e8613055565b5b6125f5858286016123f6565b9150509250929050565b6000806000606084860312156126185761261761305a565b5b600061262686828701612361565b935050602061263786828701612424565b925050604061264886828701612361565b9150509250925092565b60008060008060006080868803121561266e5761266d61305a565b5b600061267c88828901612361565b955050602061268d88828901612424565b945050604061269e88828901612361565b935050606086013567ffffffffffffffff8111156126bf576126be613055565b5b6126cb888289016123a0565b92509250509295509295909350565b6000602082840312156126f0576126ef61305a565b5b60006126fe84828501612376565b91505092915050565b60006020828403121561271d5761271c61305a565b5b600061272b8482850161238b565b91505092915050565b60006020828403121561274a5761274961305a565b5b600061275884828501612439565b91505092915050565b61276a81612f1c565b82525050565b61277981612f3a565b82525050565b600061278b8385612eef565b9350612798838584612f9f565b6127a18361305f565b840190509392505050565b60006127b88385612f00565b93506127c5838584612f9f565b82840190509392505050565b60006127dc82612ed9565b6127e68185612eef565b93506127f6818560208601612fae565b6127ff8161305f565b840191505092915050565b600061281582612ed9565b61281f8185612f00565b935061282f818560208601612fae565b80840191505092915050565b61284481612f7b565b82525050565b61285381612f8d565b82525050565b600061286482612ee4565b61286e8185612f0b565b935061287e818560208601612fae565b6128878161305f565b840191505092915050565b600061289f602683612f0b565b91506128aa82613070565b604082019050919050565b60006128c2602c83612f0b565b91506128cd826130bf565b604082019050919050565b60006128e5602c83612f0b565b91506128f08261310e565b604082019050919050565b6000612908602683612f0b565b91506129138261315d565b604082019050919050565b600061292b603883612f0b565b9150612936826131ac565b604082019050919050565b600061294e602983612f0b565b9150612959826131fb565b604082019050919050565b6000612971602e83612f0b565b915061297c8261324a565b604082019050919050565b6000612994602e83612f0b565b915061299f82613299565b604082019050919050565b60006129b7602d83612f0b565b91506129c2826132e8565b604082019050919050565b60006129da602083612f0b565b91506129e582613337565b602082019050919050565b60006129fd600083612eef565b9150612a0882613360565b600082019050919050565b6000612a20600083612f00565b9150612a2b82613360565b600082019050919050565b6000612a43601d83612f0b565b9150612a4e82613363565b602082019050919050565b6000612a66602b83612f0b565b9150612a718261338c565b604082019050919050565b6000612a89602a83612f0b565b9150612a94826133db565b604082019050919050565b612aa881612f64565b82525050565b6000612abb8284866127ac565b91508190509392505050565b6000612ad3828461280a565b915081905092915050565b6000612ae982612a13565b9150819050919050565b6000602082019050612b086000830184612761565b92915050565b6000606082019050612b236000830186612761565b612b306020830185612761565b612b3d6040830184612a9f565b949350505050565b6000604082019050612b5a6000830185612761565b612b67602083018461283b565b9392505050565b6000604082019050612b836000830185612761565b612b906020830184612a9f565b9392505050565b6000602082019050612bac6000830184612770565b92915050565b60006020820190508181036000830152612bcd81848661277f565b90509392505050565b60006020820190508181036000830152612bf081846127d1565b905092915050565b6000602082019050612c0d600083018461284a565b92915050565b60006020820190508181036000830152612c2d8184612859565b905092915050565b60006020820190508181036000830152612c4e81612892565b9050919050565b60006020820190508181036000830152612c6e816128b5565b9050919050565b60006020820190508181036000830152612c8e816128d8565b9050919050565b60006020820190508181036000830152612cae816128fb565b9050919050565b60006020820190508181036000830152612cce8161291e565b9050919050565b60006020820190508181036000830152612cee81612941565b9050919050565b60006020820190508181036000830152612d0e81612964565b9050919050565b60006020820190508181036000830152612d2e81612987565b9050919050565b60006020820190508181036000830152612d4e816129aa565b9050919050565b60006020820190508181036000830152612d6e816129cd565b9050919050565b60006020820190508181036000830152612d8e81612a36565b9050919050565b60006020820190508181036000830152612dae81612a59565b9050919050565b60006020820190508181036000830152612dce81612a7c565b9050919050565b6000606082019050612dea6000830187612a9f565b612df76020830186612761565b8181036040830152612e0a81848661277f565b905095945050505050565b6000606082019050612e2a6000830185612a9f565b612e376020830184612761565b8181036040830152612e48816129f0565b90509392505050565b6000604082019050612e666000830186612a9f565b8181036020830152612e7981848661277f565b9050949350505050565b6000612e8d612e9e565b9050612e998282612fe1565b919050565b6000604051905090565b600067ffffffffffffffff821115612ec357612ec2613012565b5b612ecc8261305f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612f2782612f44565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612f8682612f64565b9050919050565b6000612f9882612f6e565b9050919050565b82818337600083830152505050565b60005b83811015612fcc578082015181840152602081019050612fb1565b83811115612fdb576000848401525b50505050565b612fea8261305f565b810181811067ffffffffffffffff8211171561300957613008613012565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61343381612f1c565b811461343e57600080fd5b50565b61344a81612f2e565b811461345557600080fd5b50565b61346181612f3a565b811461346c57600080fd5b50565b61347881612f64565b811461348357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220a92291d9031c32880ffc1e5010a2c6663dffc6271b359692f77d40a3df8488cc64736f6c63430008070033", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. @@ -326,12 +326,12 @@ func (_GatewayEVM *GatewayEVMCallerSession) TssAddress() (common.Address, error) return _GatewayEVM.Contract.TssAddress(&_GatewayEVM.CallOpts) } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVM *GatewayEVMCaller) ZetaAsset(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zeta() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVM.contract.Call(opts, &out, "zetaAsset") + err := _GatewayEVM.contract.Call(opts, &out, "zeta") if err != nil { return *new(common.Address), err @@ -343,18 +343,18 @@ func (_GatewayEVM *GatewayEVMCaller) ZetaAsset(opts *bind.CallOpts) (common.Addr } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVM *GatewayEVMSession) ZetaAsset() (common.Address, error) { - return _GatewayEVM.Contract.ZetaAsset(&_GatewayEVM.CallOpts) +// Solidity: function zeta() view returns(address) +func (_GatewayEVM *GatewayEVMSession) Zeta() (common.Address, error) { + return _GatewayEVM.Contract.Zeta(&_GatewayEVM.CallOpts) } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVM *GatewayEVMCallerSession) ZetaAsset() (common.Address, error) { - return _GatewayEVM.Contract.ZetaAsset(&_GatewayEVM.CallOpts) +// Solidity: function zeta() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) Zeta() (common.Address, error) { + return _GatewayEVM.Contract.Zeta(&_GatewayEVM.CallOpts) } // ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. @@ -537,23 +537,23 @@ func (_GatewayEVM *GatewayEVMTransactorSession) ExecuteWithERC20(token common.Ad // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress, _zeta) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zeta) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zeta) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. diff --git a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go index 8e02d957..3123576b 100644 --- a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go +++ b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go @@ -32,7 +32,7 @@ var ( // ZetaConnectorNewMetaData contains all meta data concerning the ZetaConnectorNew contract. var ZetaConnectorNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "0x60806040523480156200001157600080fd5b50604051620011b9380380620011b9833981810160405281019062000037919062000180565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161480620000a75750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15620000df576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050506200021a565b6000815190506200017a8162000200565b92915050565b600080604083850312156200019a5762000199620001fb565b5b6000620001aa8582860162000169565b9250506020620001bd8582860162000169565b9150509250929050565b6000620001d482620001db565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200020b81620001c7565b81146200021757600080fd5b50565b610f8f806200022a6000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806302a04c0d14610051578063116191b61461006d578063e8f9cb3a1461008b578063f3fef3a3146100a9575b600080fd5b61006b6004803603810190610066919061082e565b6100c5565b005b610075610279565b6040516100829190610b20565b60405180910390f35b61009361029f565b6040516100a09190610b05565b60405180910390f35b6100c360048036038101906100be91906107ee565b6102c5565b005b6100cd610374565b61013c600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab59600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868686866040518663ffffffff1660e01b81526004016101c1959493929190610a8e565b600060405180830381600087803b1580156101db57600080fd5b505af11580156101ef573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f8201168201806040525081019061021891906108cf565b508373ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced84848460405161026393929190610bf8565b60405180910390a261027361044a565b50505050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6102cd610374565b61031a8282600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364826040516103609190610bdd565b60405180910390a261037061044a565b5050565b600260005414156103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103b190610bbd565b60405180910390fd5b6002600081905550565b6104458363a9059cbb60e01b84846040516024016103e3929190610adc565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610454565b505050565b6001600081905550565b60006104b6826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661051b9092919063ffffffff16565b905060008151111561051657808060200190518101906104d691906108a2565b610515576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050c90610b9d565b60405180910390fd5b5b505050565b606061052a8484600085610533565b90509392505050565b606082471015610578576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056f90610b5d565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516105a19190610a77565b60006040518083038185875af1925050503d80600081146105de576040519150601f19603f3d011682016040523d82523d6000602084013e6105e3565b606091505b50915091506105f487838387610600565b92505050949350505050565b606083156106635760008351141561065b5761061b85610676565b61065a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065190610b7d565b60405180910390fd5b5b82905061066e565b61066d8383610699565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106ac5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106e09190610b3b565b60405180910390fd5b60006106fc6106f784610c4f565b610c2a565b90508281526020810184848401111561071857610717610e04565b5b610723848285610d62565b509392505050565b60008135905061073a81610f14565b92915050565b60008151905061074f81610f2b565b92915050565b60008083601f84011261076b5761076a610dfa565b5b8235905067ffffffffffffffff81111561078857610787610df5565b5b6020830191508360018202830111156107a4576107a3610dff565b5b9250929050565b600082601f8301126107c0576107bf610dfa565b5b81516107d08482602086016106e9565b91505092915050565b6000813590506107e881610f42565b92915050565b6000806040838503121561080557610804610e0e565b5b60006108138582860161072b565b9250506020610824858286016107d9565b9150509250929050565b6000806000806060858703121561084857610847610e0e565b5b60006108568782880161072b565b9450506020610867878288016107d9565b935050604085013567ffffffffffffffff81111561088857610887610e09565b5b61089487828801610755565b925092505092959194509250565b6000602082840312156108b8576108b7610e0e565b5b60006108c684828501610740565b91505092915050565b6000602082840312156108e5576108e4610e0e565b5b600082015167ffffffffffffffff81111561090357610902610e09565b5b61090f848285016107ab565b91505092915050565b61092181610cc3565b82525050565b60006109338385610c96565b9350610940838584610d53565b61094983610e13565b840190509392505050565b600061095f82610c80565b6109698185610ca7565b9350610979818560208601610d62565b80840191505092915050565b61098e81610d0b565b82525050565b61099d81610d1d565b82525050565b60006109ae82610c8b565b6109b88185610cb2565b93506109c8818560208601610d62565b6109d181610e13565b840191505092915050565b60006109e9602683610cb2565b91506109f482610e24565b604082019050919050565b6000610a0c601d83610cb2565b9150610a1782610e73565b602082019050919050565b6000610a2f602a83610cb2565b9150610a3a82610e9c565b604082019050919050565b6000610a52601f83610cb2565b9150610a5d82610eeb565b602082019050919050565b610a7181610d01565b82525050565b6000610a838284610954565b915081905092915050565b6000608082019050610aa36000830188610918565b610ab06020830187610918565b610abd6040830186610a68565b8181036060830152610ad0818486610927565b90509695505050505050565b6000604082019050610af16000830185610918565b610afe6020830184610a68565b9392505050565b6000602082019050610b1a6000830184610985565b92915050565b6000602082019050610b356000830184610994565b92915050565b60006020820190508181036000830152610b5581846109a3565b905092915050565b60006020820190508181036000830152610b76816109dc565b9050919050565b60006020820190508181036000830152610b96816109ff565b9050919050565b60006020820190508181036000830152610bb681610a22565b9050919050565b60006020820190508181036000830152610bd681610a45565b9050919050565b6000602082019050610bf26000830184610a68565b92915050565b6000604082019050610c0d6000830186610a68565b8181036020830152610c20818486610927565b9050949350505050565b6000610c34610c45565b9050610c408282610d95565b919050565b6000604051905090565b600067ffffffffffffffff821115610c6a57610c69610dc6565b5b610c7382610e13565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610cce82610ce1565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610d1682610d2f565b9050919050565b6000610d2882610d2f565b9050919050565b6000610d3a82610d41565b9050919050565b6000610d4c82610ce1565b9050919050565b82818337600083830152505050565b60005b83811015610d80578082015181840152602081019050610d65565b83811115610d8f576000848401525b50505050565b610d9e82610e13565b810181811067ffffffffffffffff82111715610dbd57610dbc610dc6565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610f1d81610cc3565b8114610f2857600080fd5b50565b610f3481610cd5565b8114610f3f57600080fd5b50565b610f4b81610d01565b8114610f5657600080fd5b5056fea2646970667358221220bdea1bc357822401542c5c1b57f5c8696f7fa6c99ecfef1bfd392504260c0f1164736f6c63430008070033", + Bin: "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", } // ZetaConnectorNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go index 0eb4c3ac..49bb23b3 100644 --- a/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevm.t.sol/gatewayevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMTestMetaData contains all meta data concerning the GatewayEVMTest contract. var GatewayEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testForwardCallToReceivePayable\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go index 5cd9461e..c736c2d6 100644 --- a/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go +++ b/pkg/contracts/prototypes/test/gatewayevmzevm.t.sol/gatewayevmzevmtest.go @@ -50,7 +50,7 @@ type StdInvariantFuzzSelector struct { // GatewayEVMZEVMTestMetaData contains all meta data concerning the GatewayEVMZEVMTest contract. var GatewayEVMZEVMTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"}],\"name\":\"ReceivedERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"ReceivedNoParams\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string[]\",\"name\":\"strs\",\"type\":\"string[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"nums\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedNonPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"ReceivedPayable\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"log_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"log_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"log_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"\",\"type\":\"int256\"}],\"name\":\"log_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"val\",\"type\":\"address\"}],\"name\":\"log_named_address\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"val\",\"type\":\"uint256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256[]\",\"name\":\"val\",\"type\":\"int256[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"val\",\"type\":\"address[]\"}],\"name\":\"log_named_array\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"val\",\"type\":\"bytes\"}],\"name\":\"log_named_bytes\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"val\",\"type\":\"bytes32\"}],\"name\":\"log_named_bytes32\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"decimals\",\"type\":\"uint256\"}],\"name\":\"log_named_decimal_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"int256\",\"name\":\"val\",\"type\":\"int256\"}],\"name\":\"log_named_int\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"val\",\"type\":\"string\"}],\"name\":\"log_named_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"key\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"val\",\"type\":\"uint256\"}],\"name\":\"log_named_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"name\":\"log_string\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"log_uint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"logs\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"IS_TEST\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"excludedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"excludedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"excludeSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"excludedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"failed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"setUp\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifactSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"string\",\"name\":\"artifact\",\"type\":\"string\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzArtifactSelector[]\",\"name\":\"targetedArtifactSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetArtifacts\",\"outputs\":[{\"internalType\":\"string[]\",\"name\":\"targetedArtifacts_\",\"type\":\"string[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetContracts\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedContracts_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetInterfaces\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"string[]\",\"name\":\"artifacts\",\"type\":\"string[]\"}],\"internalType\":\"structStdInvariant.FuzzInterface[]\",\"name\":\"targetedInterfaces_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSelectors\",\"outputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"},{\"internalType\":\"bytes4[]\",\"name\":\"selectors\",\"type\":\"bytes4[]\"}],\"internalType\":\"structStdInvariant.FuzzSelector[]\",\"name\":\"targetedSelectors_\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"targetSenders\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"targetedSenders_\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"testCallReceiverEVMFromZEVM\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMZEVMTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 87fa11ad..6e574512 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -39,7 +39,7 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_wzeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wzeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b8152503480156200004757600080fd5b50620000586200005e60201b60201c565b62000208565b600060019054906101000a900460ff1615620000b1576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401620000a8906200015c565b60405180910390fd5b60ff801660008054906101000a900460ff1660ff1614620001225760ff6000806101000a81548160ff021916908360ff1602179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860ff6040516200011991906200017e565b60405180910390a15b565b6000620001336027836200019b565b91506200014082620001b9565b604082019050919050565b6200015681620001ac565b82525050565b60006020820190508181036000830152620001778162000124565b9050919050565b60006020820190506200019560008301846200014b565b92915050565b600082825260208201905092915050565b600060ff82169050919050565b7f496e697469616c697a61626c653a20636f6e747261637420697320696e69746960008201527f616c697a696e6700000000000000000000000000000000000000000000000000602082015250565b60805160601c6135f1620002436000396000818161086b015281816108fa01528181610a0c01528181610a9b0152610b4b01526135f16000f3fe6080604052600436106101085760003560e01c806352d1902d11610095578063bcf7f32b11610064578063bcf7f32b1461030b578063c39aca3714610334578063c4d66de81461035d578063f2fde38b14610386578063f45346dc146103af57610108565b806352d1902d14610275578063715018a6146102a05780637993c1e0146102b75780638da5cb5b146102e057610108565b8063267e75a0116100dc578063267e75a0146101b35780632e1a7d4d146101dc5780633659cfe6146102055780633ce4a5bc1461022e5780634f1ef2861461025957610108565b8062173d461461010d5780630ac7c44c14610138578063135390f91461016157806321501a951461018a575b600080fd5b34801561011957600080fd5b506101226103d8565b60405161012f9190612ab0565b60405180910390f35b34801561014457600080fd5b5061015f600480360381019061015a9190612318565b6103fe565b005b34801561016d57600080fd5b5061018860048036038101906101839190612394565b610455565b005b34801561019657600080fd5b506101b160048036038101906101ac919061255d565b61053c565b005b3480156101bf57600080fd5b506101da60048036038101906101d5919061265b565b61070b565b005b3480156101e857600080fd5b5061020360048036038101906101fe9190612601565b6107bd565b005b34801561021157600080fd5b5061022c600480360381019061022791906121a2565b610869565b005b34801561023a57600080fd5b506102436109f2565b6040516102509190612ab0565b60405180910390f35b610273600480360381019061026e91906121cf565b610a0a565b005b34801561028157600080fd5b5061028a610b47565b6040516102979190612ce7565b60405180910390f35b3480156102ac57600080fd5b506102b5610c00565b005b3480156102c357600080fd5b506102de60048036038101906102d99190612403565b610c14565b005b3480156102ec57600080fd5b506102f5610d01565b6040516103029190612ab0565b60405180910390f35b34801561031757600080fd5b50610332600480360381019061032d91906124a7565b610d2b565b005b34801561034057600080fd5b5061035b600480360381019061035691906124a7565b610e1f565b005b34801561036957600080fd5b50610384600480360381019061037f91906121a2565b611051565b005b34801561039257600080fd5b506103ad60048036038101906103a891906121a2565b6111d9565b005b3480156103bb57600080fd5b506103d660048036038101906103d1919061226b565b61125d565b005b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b3373ffffffffffffffffffffffffffffffffffffffff167f2b5af078ce280d812dc2241658dc5435c93408020e5418eef55a2b536de51c0f84848460405161044893929190612d02565b60405180910390a2505050565b60006104618383611419565b90503373ffffffffffffffffffffffffffffffffffffffff167f2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716838686858773ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156104e557600080fd5b505afa1580156104f9573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061051d919061262e565b60405161052e959493929190612c51565b60405180910390a250505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146105b5576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16148061062e57503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610665576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61066f8484611709565b8273ffffffffffffffffffffffffffffffffffffffff1663de43156e8660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff168786866040518663ffffffff1660e01b81526004016106d2959493929190612ed8565b600060405180830381600087803b1580156106ec57600080fd5b505af1158015610700573d6000803e3d6000fd5b505050505050505050565b6107298373735b14bb79463307aacbed86daf3322b1e6226ab611709565b3373ffffffffffffffffffffffffffffffffffffffff167f2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716600073735b14bb79463307aacbed86daf3322b1e6226ab6040516020016107889190612a69565b6040516020818303038152906040528660008088886040516107b09796959493929190612b02565b60405180910390a2505050565b6107db8173735b14bb79463307aacbed86daf3322b1e6226ab611709565b3373ffffffffffffffffffffffffffffffffffffffff167f2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716600073735b14bb79463307aacbed86daf3322b1e6226ab60405160200161083a9190612a69565b6040516020818303038152906040528460008060405161085e959493929190612b73565b60405180910390a250565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156108f8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108ef90612d98565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610937611925565b73ffffffffffffffffffffffffffffffffffffffff161461098d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161098490612db8565b60405180910390fd5b6109968161197c565b6109ef81600067ffffffffffffffff8111156109b5576109b461319d565b5b6040519080825280601f01601f1916602001820160405280156109e75781602001600182028036833780820191505090505b506000611987565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab81565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610a99576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610a9090612d98565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610ad8611925565b73ffffffffffffffffffffffffffffffffffffffff1614610b2e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610b2590612db8565b60405180910390fd5b610b378261197c565b610b4382826001611987565b5050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614610bd7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bce90612dd8565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b610c08611b04565b610c126000611b82565b565b6000610c208585611419565b90503373ffffffffffffffffffffffffffffffffffffffff167f2265ce9ec38ea098a1143406678482665a6e1ccd82ab22d37eea3a78abc57716858888858973ffffffffffffffffffffffffffffffffffffffff16634d8943bb6040518163ffffffff1660e01b815260040160206040518083038186803b158015610ca457600080fd5b505afa158015610cb8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610cdc919061262e565b8989604051610cf19796959493929190612be0565b60405180910390a2505050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610da4576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401610de5959493929190612ed8565b600060405180830381600087803b158015610dff57600080fd5b505af1158015610e13573d6000803e3d6000fd5b50505050505050505050565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610e98576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161480610f1157503073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff16145b15610f48576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8473ffffffffffffffffffffffffffffffffffffffff166347e7ef2484866040518363ffffffff1660e01b8152600401610f83929190612cbe565b602060405180830381600087803b158015610f9d57600080fd5b505af1158015610fb1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fd591906122be565b508273ffffffffffffffffffffffffffffffffffffffff1663de43156e87878786866040518663ffffffff1660e01b8152600401611017959493929190612ed8565b600060405180830381600087803b15801561103157600080fd5b505af1158015611045573d6000803e3d6000fd5b50505050505050505050565b60008060019054906101000a900460ff161590508080156110825750600160008054906101000a900460ff1660ff16105b806110af575061109130611c48565b1580156110ae5750600160008054906101000a900460ff1660ff16145b5b6110ee576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110e590612e18565b60405180910390fd5b60016000806101000a81548160ff021916908360ff160217905550801561112b576001600060016101000a81548160ff0219169083151502179055505b611133611c6b565b61113b611cc4565b8160c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080156111d55760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249860016040516111cc9190612d3b565b60405180910390a15b5050565b6111e1611b04565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611251576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161124890612d78565b60405180910390fd5b61125a81611b82565b50565b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146112d6576040517f2b2add3d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b73735b14bb79463307aacbed86daf3322b1e6226ab73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16148061134f57503073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15611386576040517f82d5d76a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8273ffffffffffffffffffffffffffffffffffffffff166347e7ef2482846040518363ffffffff1660e01b81526004016113c1929190612cbe565b602060405180830381600087803b1580156113db57600080fd5b505af11580156113ef573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061141391906122be565b50505050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1663d9eeebed6040518163ffffffff1660e01b8152600401604080518083038186803b15801561146357600080fd5b505afa158015611477573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061149b919061222b565b915091508173ffffffffffffffffffffffffffffffffffffffff166323b872dd3373735b14bb79463307aacbed86daf3322b1e6226ab846040518463ffffffff1660e01b81526004016114f093929190612acb565b602060405180830381600087803b15801561150a57600080fd5b505af115801561151e573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061154291906122be565b611578576040517f0a7cd6d600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166323b872dd3330886040518463ffffffff1660e01b81526004016115b593929190612acb565b602060405180830381600087803b1580156115cf57600080fd5b505af11580156115e3573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061160791906122be565b61163d576040517f4dd9ee8d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff166342966c68866040518263ffffffff1660e01b81526004016116769190612f2d565b602060405180830381600087803b15801561169057600080fd5b505af11580156116a4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906116c891906122be565b6116fe576040517f2c77e05c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b809250505092915050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166323b872dd3330856040518463ffffffff1660e01b815260040161176893929190612acb565b602060405180830381600087803b15801561178257600080fd5b505af1158015611796573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117ba91906122be565b6117f0576040517fa8c6fd4a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16632e1a7d4d836040518263ffffffff1660e01b815260040161184b9190612f2d565b600060405180830381600087803b15801561186557600080fd5b505af1158015611879573d6000803e3d6000fd5b5050505060008173ffffffffffffffffffffffffffffffffffffffff16836040516118a390612a9b565b60006040518083038185875af1925050503d80600081146118e0576040519150601f19603f3d011682016040523d82523d6000602084013e6118e5565b606091505b5050905080611920576040517fc7ffc47b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050565b60006119537f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d15565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b611984611b04565b50565b6119b37f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611d1f565b60000160009054906101000a900460ff16156119d7576119d283611d29565b611aff565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b158015611a1d57600080fd5b505afa925050508015611a4e57506040513d601f19601f82011682018060405250810190611a4b91906122eb565b60015b611a8d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a8490612e38565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611af2576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ae990612df8565b60405180910390fd5b50611afe838383611de2565b5b505050565b611b0c611e0e565b73ffffffffffffffffffffffffffffffffffffffff16611b2a610d01565b73ffffffffffffffffffffffffffffffffffffffff1614611b80576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611b7790612e78565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611cba576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611cb190612eb8565b60405180910390fd5b611cc2611e16565b565b600060019054906101000a900460ff16611d13576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d0a90612eb8565b60405180910390fd5b565b6000819050919050565b6000819050919050565b611d3281611c48565b611d71576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611d6890612e58565b60405180910390fd5b80611d9e7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d15565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611deb83611e77565b600082511180611df85750805b15611e0957611e078383611ec6565b505b505050565b600033905090565b600060019054906101000a900460ff16611e65576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e5c90612eb8565b60405180910390fd5b611e75611e70611e0e565b611b82565b565b611e8081611d29565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611eeb838360405180606001604052806027815260200161359560279139611ef3565b905092915050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1685604051611f1d9190612a84565b600060405180830381855af49150503d8060008114611f58576040519150601f19603f3d011682016040523d82523d6000602084013e611f5d565b606091505b5091509150611f6e86838387611f79565b925050509392505050565b60608315611fdc57600083511415611fd457611f9485611c48565b611fd3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611fca90612e98565b60405180910390fd5b5b829050611fe7565b611fe68383611fef565b5b949350505050565b6000825111156120025781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120369190612d56565b60405180910390fd5b600061205261204d84612f6d565b612f48565b90508281526020810184848401111561206e5761206d6131ea565b5b612079848285613106565b509392505050565b60008135905061209081613538565b92915050565b6000815190506120a581613538565b92915050565b6000815190506120ba8161354f565b92915050565b6000815190506120cf81613566565b92915050565b60008083601f8401126120eb576120ea6131d6565b5b8235905067ffffffffffffffff811115612108576121076131d1565b5b602083019150836001820283011115612124576121236131e5565b5b9250929050565b600082601f8301126121405761213f6131d6565b5b813561215084826020860161203f565b91505092915050565b60006060828403121561216f5761216e6131db565b5b81905092915050565b6000813590506121878161357d565b92915050565b60008151905061219c8161357d565b92915050565b6000602082840312156121b8576121b76131f9565b5b60006121c684828501612081565b91505092915050565b600080604083850312156121e6576121e56131f9565b5b60006121f485828601612081565b925050602083013567ffffffffffffffff811115612215576122146131ef565b5b6122218582860161212b565b9150509250929050565b60008060408385031215612242576122416131f9565b5b600061225085828601612096565b92505060206122618582860161218d565b9150509250929050565b600080600060608486031215612284576122836131f9565b5b600061229286828701612081565b93505060206122a386828701612178565b92505060406122b486828701612081565b9150509250925092565b6000602082840312156122d4576122d36131f9565b5b60006122e2848285016120ab565b91505092915050565b600060208284031215612301576123006131f9565b5b600061230f848285016120c0565b91505092915050565b600080600060408486031215612331576123306131f9565b5b600084013567ffffffffffffffff81111561234f5761234e6131ef565b5b61235b8682870161212b565b935050602084013567ffffffffffffffff81111561237c5761237b6131ef565b5b612388868287016120d5565b92509250509250925092565b6000806000606084860312156123ad576123ac6131f9565b5b600084013567ffffffffffffffff8111156123cb576123ca6131ef565b5b6123d78682870161212b565b93505060206123e886828701612178565b92505060406123f986828701612081565b9150509250925092565b60008060008060006080868803121561241f5761241e6131f9565b5b600086013567ffffffffffffffff81111561243d5761243c6131ef565b5b6124498882890161212b565b955050602061245a88828901612178565b945050604061246b88828901612081565b935050606086013567ffffffffffffffff81111561248c5761248b6131ef565b5b612498888289016120d5565b92509250509295509295909350565b60008060008060008060a087890312156124c4576124c36131f9565b5b600087013567ffffffffffffffff8111156124e2576124e16131ef565b5b6124ee89828a01612159565b96505060206124ff89828a01612081565b955050604061251089828a01612178565b945050606061252189828a01612081565b935050608087013567ffffffffffffffff811115612542576125416131ef565b5b61254e89828a016120d5565b92509250509295509295509295565b600080600080600060808688031215612579576125786131f9565b5b600086013567ffffffffffffffff811115612597576125966131ef565b5b6125a388828901612159565b95505060206125b488828901612178565b94505060406125c588828901612081565b935050606086013567ffffffffffffffff8111156125e6576125e56131ef565b5b6125f2888289016120d5565b92509250509295509295909350565b600060208284031215612617576126166131f9565b5b600061262584828501612178565b91505092915050565b600060208284031215612644576126436131f9565b5b60006126528482850161218d565b91505092915050565b600080600060408486031215612674576126736131f9565b5b600061268286828701612178565b935050602084013567ffffffffffffffff8111156126a3576126a26131ef565b5b6126af868287016120d5565b92509250509250925092565b6126c481613083565b82525050565b6126d381613083565b82525050565b6126ea6126e582613083565b613179565b82525050565b6126f9816130a1565b82525050565b600061270b8385612fb4565b9350612718838584613106565b612721836131fe565b840190509392505050565b60006127388385612fc5565b9350612745838584613106565b61274e836131fe565b840190509392505050565b600061276482612f9e565b61276e8185612fc5565b935061277e818560208601613115565b612787816131fe565b840191505092915050565b600061279d82612f9e565b6127a78185612fd6565b93506127b7818560208601613115565b80840191505092915050565b6127cc816130e2565b82525050565b6127db816130f4565b82525050565b60006127ec82612fa9565b6127f68185612fe1565b9350612806818560208601613115565b61280f816131fe565b840191505092915050565b6000612827602683612fe1565b91506128328261321c565b604082019050919050565b600061284a602c83612fe1565b91506128558261326b565b604082019050919050565b600061286d602c83612fe1565b9150612878826132ba565b604082019050919050565b6000612890603883612fe1565b915061289b82613309565b604082019050919050565b60006128b3602983612fe1565b91506128be82613358565b604082019050919050565b60006128d6602e83612fe1565b91506128e1826133a7565b604082019050919050565b60006128f9602e83612fe1565b9150612904826133f6565b604082019050919050565b600061291c602d83612fe1565b915061292782613445565b604082019050919050565b600061293f602083612fe1565b915061294a82613494565b602082019050919050565b6000612962600083612fc5565b915061296d826134bd565b600082019050919050565b6000612985600083612fd6565b9150612990826134bd565b600082019050919050565b60006129a8601d83612fe1565b91506129b3826134c0565b602082019050919050565b60006129cb602b83612fe1565b91506129d6826134e9565b604082019050919050565b6000606083016129f46000840184613009565b8583036000870152612a078382846126ff565b92505050612a186020840184612ff2565b612a2560208601826126bb565b50612a33604084018461306c565b612a406040860182612a4b565b508091505092915050565b612a54816130cb565b82525050565b612a63816130cb565b82525050565b6000612a7582846126d9565b60148201915081905092915050565b6000612a908284612792565b915081905092915050565b6000612aa682612978565b9150819050919050565b6000602082019050612ac560008301846126ca565b92915050565b6000606082019050612ae060008301866126ca565b612aed60208301856126ca565b612afa6040830184612a5a565b949350505050565b600060c082019050612b17600083018a6126ca565b8181036020830152612b298189612759565b9050612b386040830188612a5a565b612b4560608301876127c3565b612b5260808301866127c3565b81810360a0830152612b6581848661272c565b905098975050505050505050565b600060c082019050612b8860008301886126ca565b8181036020830152612b9a8187612759565b9050612ba96040830186612a5a565b612bb660608301856127c3565b612bc360808301846127c3565b81810360a0830152612bd481612955565b90509695505050505050565b600060c082019050612bf5600083018a6126ca565b8181036020830152612c078189612759565b9050612c166040830188612a5a565b612c236060830187612a5a565b612c306080830186612a5a565b81810360a0830152612c4381848661272c565b905098975050505050505050565b600060c082019050612c6660008301886126ca565b8181036020830152612c788187612759565b9050612c876040830186612a5a565b612c946060830185612a5a565b612ca16080830184612a5a565b81810360a0830152612cb281612955565b90509695505050505050565b6000604082019050612cd360008301856126ca565b612ce06020830184612a5a565b9392505050565b6000602082019050612cfc60008301846126f0565b92915050565b60006040820190508181036000830152612d1c8186612759565b90508181036020830152612d3181848661272c565b9050949350505050565b6000602082019050612d5060008301846127d2565b92915050565b60006020820190508181036000830152612d7081846127e1565b905092915050565b60006020820190508181036000830152612d918161281a565b9050919050565b60006020820190508181036000830152612db18161283d565b9050919050565b60006020820190508181036000830152612dd181612860565b9050919050565b60006020820190508181036000830152612df181612883565b9050919050565b60006020820190508181036000830152612e11816128a6565b9050919050565b60006020820190508181036000830152612e31816128c9565b9050919050565b60006020820190508181036000830152612e51816128ec565b9050919050565b60006020820190508181036000830152612e718161290f565b9050919050565b60006020820190508181036000830152612e9181612932565b9050919050565b60006020820190508181036000830152612eb18161299b565b9050919050565b60006020820190508181036000830152612ed1816129be565b9050919050565b60006080820190508181036000830152612ef281886129e1565b9050612f0160208301876126ca565b612f0e6040830186612a5a565b8181036060830152612f2181848661272c565b90509695505050505050565b6000602082019050612f426000830184612a5a565b92915050565b6000612f52612f63565b9050612f5e8282613148565b919050565b6000604051905090565b600067ffffffffffffffff821115612f8857612f8761319d565b5b612f91826131fe565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b60006130016020840184612081565b905092915050565b60008083356001602003843603038112613026576130256131f4565b5b83810192508235915060208301925067ffffffffffffffff82111561304e5761304d6131cc565b5b600182023603841315613064576130636131e0565b5b509250929050565b600061307b6020840184612178565b905092915050565b600061308e826130ab565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b60006130ed826130cb565b9050919050565b60006130ff826130d5565b9050919050565b82818337600083830152505050565b60005b83811015613133578082015181840152602081019050613118565b83811115613142576000848401525b50505050565b613151826131fe565b810181811067ffffffffffffffff821117156131705761316f61319d565b5b80604052505050565b60006131848261318b565b9050919050565b60006131968261320f565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b60008160601b9050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b61354181613083565b811461354c57600080fd5b50565b61355881613095565b811461356357600080fd5b50565b61356f816130a1565b811461357a57600080fd5b50565b613586816130cb565b811461359157600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220a02701821455f4cf4d4090f64f434d6e3d013dc7ecb314426e58242866ea7d6a64736f6c63430008070033", } // GatewayZEVMABI is the input ABI used to generate the binding from. diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts index 5b4d61dc..82a91b20 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -48,7 +48,7 @@ export interface GatewayEVMInterface extends utils.Interface { "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; - "zetaAsset()": FunctionFragment; + "zeta()": FunctionFragment; "zetaConnector()": FunctionFragment; }; @@ -72,7 +72,7 @@ export interface GatewayEVMInterface extends utils.Interface { | "tssAddress" | "upgradeTo" | "upgradeToAndCall" - | "zetaAsset" + | "zeta" | "zetaConnector" ): FunctionFragment; @@ -156,7 +156,7 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; - encodeFunctionData(functionFragment: "zetaAsset", values?: undefined): string; + encodeFunctionData(functionFragment: "zeta", values?: undefined): string; encodeFunctionData( functionFragment: "zetaConnector", values?: undefined @@ -210,7 +210,7 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "zetaAsset", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; decodeFunctionResult( functionFragment: "zetaConnector", data: BytesLike @@ -412,7 +412,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -452,7 +452,7 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise<[string]>; + zeta(overrides?: CallOverrides): Promise<[string]>; zetaConnector(overrides?: CallOverrides): Promise<[string]>; }; @@ -507,7 +507,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -547,7 +547,7 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; @@ -602,7 +602,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -640,7 +640,7 @@ export interface GatewayEVM extends BaseContract { overrides?: CallOverrides ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; @@ -783,7 +783,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -823,7 +823,7 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; @@ -879,7 +879,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -919,7 +919,7 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 2b48d911..93bf08b3 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -425,7 +425,7 @@ const _abi = [ }, { internalType: "address", - name: "_zetaAsset", + name: "_zeta", type: "address", }, ], @@ -552,7 +552,7 @@ const _abi = [ }, { inputs: [], - name: "zetaAsset", + name: "zeta", outputs: [ { internalType: "address", @@ -579,7 +579,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts index 5889be8f..3c19e1c1 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts @@ -145,7 +145,7 @@ const _abi = [ ] as const; const _bytecode = - "0x60806040523480156200001157600080fd5b50604051620011b9380380620011b9833981810160405281019062000037919062000180565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161480620000a75750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15620000df576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050506200021a565b6000815190506200017a8162000200565b92915050565b600080604083850312156200019a5762000199620001fb565b5b6000620001aa8582860162000169565b9250506020620001bd8582860162000169565b9150509250929050565b6000620001d482620001db565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200020b81620001c7565b81146200021757600080fd5b50565b610f8f806200022a6000396000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806302a04c0d14610051578063116191b61461006d578063e8f9cb3a1461008b578063f3fef3a3146100a9575b600080fd5b61006b6004803603810190610066919061082e565b6100c5565b005b610075610279565b6040516100829190610b20565b60405180910390f35b61009361029f565b6040516100a09190610b05565b60405180910390f35b6100c360048036038101906100be91906107ee565b6102c5565b005b6100cd610374565b61013c600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1684600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab59600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16868686866040518663ffffffff1660e01b81526004016101c1959493929190610a8e565b600060405180830381600087803b1580156101db57600080fd5b505af11580156101ef573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f8201168201806040525081019061021891906108cf565b508373ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced84848460405161026393929190610bf8565b60405180910390a261027361044a565b50505050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6102cd610374565b61031a8282600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166103c49092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364826040516103609190610bdd565b60405180910390a261037061044a565b5050565b600260005414156103ba576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103b190610bbd565b60405180910390fd5b6002600081905550565b6104458363a9059cbb60e01b84846040516024016103e3929190610adc565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610454565b505050565b6001600081905550565b60006104b6826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661051b9092919063ffffffff16565b905060008151111561051657808060200190518101906104d691906108a2565b610515576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161050c90610b9d565b60405180910390fd5b5b505050565b606061052a8484600085610533565b90509392505050565b606082471015610578576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056f90610b5d565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516105a19190610a77565b60006040518083038185875af1925050503d80600081146105de576040519150601f19603f3d011682016040523d82523d6000602084013e6105e3565b606091505b50915091506105f487838387610600565b92505050949350505050565b606083156106635760008351141561065b5761061b85610676565b61065a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065190610b7d565b60405180910390fd5b5b82905061066e565b61066d8383610699565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106ac5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106e09190610b3b565b60405180910390fd5b60006106fc6106f784610c4f565b610c2a565b90508281526020810184848401111561071857610717610e04565b5b610723848285610d62565b509392505050565b60008135905061073a81610f14565b92915050565b60008151905061074f81610f2b565b92915050565b60008083601f84011261076b5761076a610dfa565b5b8235905067ffffffffffffffff81111561078857610787610df5565b5b6020830191508360018202830111156107a4576107a3610dff565b5b9250929050565b600082601f8301126107c0576107bf610dfa565b5b81516107d08482602086016106e9565b91505092915050565b6000813590506107e881610f42565b92915050565b6000806040838503121561080557610804610e0e565b5b60006108138582860161072b565b9250506020610824858286016107d9565b9150509250929050565b6000806000806060858703121561084857610847610e0e565b5b60006108568782880161072b565b9450506020610867878288016107d9565b935050604085013567ffffffffffffffff81111561088857610887610e09565b5b61089487828801610755565b925092505092959194509250565b6000602082840312156108b8576108b7610e0e565b5b60006108c684828501610740565b91505092915050565b6000602082840312156108e5576108e4610e0e565b5b600082015167ffffffffffffffff81111561090357610902610e09565b5b61090f848285016107ab565b91505092915050565b61092181610cc3565b82525050565b60006109338385610c96565b9350610940838584610d53565b61094983610e13565b840190509392505050565b600061095f82610c80565b6109698185610ca7565b9350610979818560208601610d62565b80840191505092915050565b61098e81610d0b565b82525050565b61099d81610d1d565b82525050565b60006109ae82610c8b565b6109b88185610cb2565b93506109c8818560208601610d62565b6109d181610e13565b840191505092915050565b60006109e9602683610cb2565b91506109f482610e24565b604082019050919050565b6000610a0c601d83610cb2565b9150610a1782610e73565b602082019050919050565b6000610a2f602a83610cb2565b9150610a3a82610e9c565b604082019050919050565b6000610a52601f83610cb2565b9150610a5d82610eeb565b602082019050919050565b610a7181610d01565b82525050565b6000610a838284610954565b915081905092915050565b6000608082019050610aa36000830188610918565b610ab06020830187610918565b610abd6040830186610a68565b8181036060830152610ad0818486610927565b90509695505050505050565b6000604082019050610af16000830185610918565b610afe6020830184610a68565b9392505050565b6000602082019050610b1a6000830184610985565b92915050565b6000602082019050610b356000830184610994565b92915050565b60006020820190508181036000830152610b5581846109a3565b905092915050565b60006020820190508181036000830152610b76816109dc565b9050919050565b60006020820190508181036000830152610b96816109ff565b9050919050565b60006020820190508181036000830152610bb681610a22565b9050919050565b60006020820190508181036000830152610bd681610a45565b9050919050565b6000602082019050610bf26000830184610a68565b92915050565b6000604082019050610c0d6000830186610a68565b8181036020830152610c20818486610927565b9050949350505050565b6000610c34610c45565b9050610c408282610d95565b919050565b6000604051905090565b600067ffffffffffffffff821115610c6a57610c69610dc6565b5b610c7382610e13565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610cce82610ce1565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610d1682610d2f565b9050919050565b6000610d2882610d2f565b9050919050565b6000610d3a82610d41565b9050919050565b6000610d4c82610ce1565b9050919050565b82818337600083830152505050565b60005b83811015610d80578082015181840152602081019050610d65565b83811115610d8f576000848401525b50505050565b610d9e82610e13565b810181811067ffffffffffffffff82111715610dbd57610dbc610dc6565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610f1d81610cc3565b8114610f2857600080fd5b50565b610f3481610cd5565b8114610f3f57600080fd5b50565b610f4b81610d01565b8114610f5657600080fd5b5056fea2646970667358221220bdea1bc357822401542c5c1b57f5c8696f7fa6c99ecfef1bfd392504260c0f1164736f6c63430008070033"; + "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"; type ZetaConnectorNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts index 8c196ce2..f7b4c4b1 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVM.t.sol/GatewayEVMTest__factory.ts @@ -860,7 +860,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts index f471c20e..d573fdeb 100644 --- a/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/test/GatewayEVMZEVM.t.sol/GatewayEVMZEVMTest__factory.ts @@ -979,7 +979,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMZEVMTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index bf4069a8..b3212e3f 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -598,7 +598,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] From 399f3185bbd8d6d975264a3f6604e99ab23e8cca Mon Sep 17 00:00:00 2001 From: skosito Date: Tue, 16 Jul 2024 16:00:08 +0200 Subject: [PATCH 76/86] fix --- lib/openzeppelin-foundry-upgrades | 1 - 1 file changed, 1 deletion(-) delete mode 160000 lib/openzeppelin-foundry-upgrades diff --git a/lib/openzeppelin-foundry-upgrades b/lib/openzeppelin-foundry-upgrades deleted file mode 160000 index 4cd15fc5..00000000 --- a/lib/openzeppelin-foundry-upgrades +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 4cd15fc50b141c77d8cc9ff8efb44d00e841a299 From 65b25d3869d46ffbc2992613cf864e87aec33a56 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 17 Jul 2024 16:54:13 +0200 Subject: [PATCH 77/86] fix after merge --- testFoundry/GatewayEVM.t.sol | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/testFoundry/GatewayEVM.t.sol b/testFoundry/GatewayEVM.t.sol index 2de4830a..0e27128a 100644 --- a/testFoundry/GatewayEVM.t.sol +++ b/testFoundry/GatewayEVM.t.sol @@ -7,6 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -21,7 +22,9 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; + ZetaConnectorNew zetaConnector; TestERC20 token; + TestERC20 zeta; address owner; address destination; address tssAddress; @@ -35,15 +38,19 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver tssAddress = address(0x5678); token = new TestERC20("test", "TTK"); + zeta = new TestERC20("zeta", "ZETA"); + proxy = address(new ERC1967Proxy( address(new GatewayEVM()), - abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress)) + abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress, zeta)) )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); + zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); + gateway.setConnector(address(zetaConnector)); token.mint(owner, 1000000); token.transfer(address(custody), 500000); From 718787f7b09d6fe521474003c191f9c81e7c0548 Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 17 Jul 2024 16:55:49 +0200 Subject: [PATCH 78/86] generate --- .../prototypes/evm/gatewayevm.sol/gatewayevm.go | 2 +- .../gatewayevmupgradetest.sol/gatewayevmupgradetest.go | 2 +- .../evm/zetaconnectornew.sol/zetaconnectornew.go | 2 +- .../prototypes/evm/GatewayEVMUpgradeTest__factory.ts | 2 +- .../contracts/prototypes/evm/GatewayEVM__factory.ts | 2 +- .../prototypes/evm/ZetaConnectorNew__factory.ts | 2 +- typechain-types/hardhat.d.ts | 9 +++++++++ typechain-types/index.ts | 2 ++ 8 files changed, 17 insertions(+), 6 deletions(-) diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index f36dfc03..cb5e4857 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -32,7 +32,7 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index e3dff1ba..49719dc3 100644 --- a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -32,7 +32,7 @@ var ( // GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaAsset\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go index 3123576b..7b5fca00 100644 --- a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go +++ b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go @@ -32,7 +32,7 @@ var ( // ZetaConnectorNewMetaData contains all meta data concerning the ZetaConnectorNew contract. var ZetaConnectorNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60c06040523480156200001157600080fd5b50604051620011d4380380620011d483398181016040528101906200003791906200016c565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161480620000a75750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b15620000df576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b81525050505062000206565b6000815190506200016681620001ec565b92915050565b60008060408385031215620001865762000185620001e7565b5b6000620001968582860162000155565b9250506020620001a98582860162000155565b9150509250929050565b6000620001c082620001c7565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b620001f781620001b3565b81146200020357600080fd5b50565b60805160601c60a05160601c610f81620002536000396000818160f4015281816101760152818161029701526102c801526000818160d20152818161013a01526102730152610f816000f3fe608060405234801561001057600080fd5b506004361061004c5760003560e01c806302a04c0d14610051578063116191b61461006d578063e8f9cb3a1461008b578063f3fef3a3146100a9575b600080fd5b61006b60048036038101906100669190610820565b6100c5565b005b610075610271565b6040516100829190610b12565b60405180910390f35b610093610295565b6040516100a09190610af7565b60405180910390f35b6100c360048036038101906100be91906107e0565b6102b9565b005b6100cd610366565b6101387f0000000000000000000000000000000000000000000000000000000000000000847f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166103b69092919063ffffffff16565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635131ab597f0000000000000000000000000000000000000000000000000000000000000000868686866040518663ffffffff1660e01b81526004016101b9959493929190610a80565b600060405180830381600087803b1580156101d357600080fd5b505af11580156101e7573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f8201168201806040525081019061021091906108c1565b508373ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced84848460405161025b93929190610bea565b60405180910390a261026b61043c565b50505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6102c1610366565b61030c82827f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166103b69092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364826040516103529190610bcf565b60405180910390a261036261043c565b5050565b600260005414156103ac576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016103a390610baf565b60405180910390fd5b6002600081905550565b6104378363a9059cbb60e01b84846040516024016103d5929190610ace565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050610446565b505050565b6001600081905550565b60006104a8826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661050d9092919063ffffffff16565b905060008151111561050857808060200190518101906104c89190610894565b610507576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104fe90610b8f565b60405180910390fd5b5b505050565b606061051c8484600085610525565b90509392505050565b60608247101561056a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161056190610b4f565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516105939190610a69565b60006040518083038185875af1925050503d80600081146105d0576040519150601f19603f3d011682016040523d82523d6000602084013e6105d5565b606091505b50915091506105e6878383876105f2565b92505050949350505050565b606083156106555760008351141561064d5761060d85610668565b61064c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161064390610b6f565b60405180910390fd5b5b829050610660565b61065f838361068b565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b60008251111561069e5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016106d29190610b2d565b60405180910390fd5b60006106ee6106e984610c41565b610c1c565b90508281526020810184848401111561070a57610709610df6565b5b610715848285610d54565b509392505050565b60008135905061072c81610f06565b92915050565b60008151905061074181610f1d565b92915050565b60008083601f84011261075d5761075c610dec565b5b8235905067ffffffffffffffff81111561077a57610779610de7565b5b60208301915083600182028301111561079657610795610df1565b5b9250929050565b600082601f8301126107b2576107b1610dec565b5b81516107c28482602086016106db565b91505092915050565b6000813590506107da81610f34565b92915050565b600080604083850312156107f7576107f6610e00565b5b60006108058582860161071d565b9250506020610816858286016107cb565b9150509250929050565b6000806000806060858703121561083a57610839610e00565b5b60006108488782880161071d565b9450506020610859878288016107cb565b935050604085013567ffffffffffffffff81111561087a57610879610dfb565b5b61088687828801610747565b925092505092959194509250565b6000602082840312156108aa576108a9610e00565b5b60006108b884828501610732565b91505092915050565b6000602082840312156108d7576108d6610e00565b5b600082015167ffffffffffffffff8111156108f5576108f4610dfb565b5b6109018482850161079d565b91505092915050565b61091381610cb5565b82525050565b60006109258385610c88565b9350610932838584610d45565b61093b83610e05565b840190509392505050565b600061095182610c72565b61095b8185610c99565b935061096b818560208601610d54565b80840191505092915050565b61098081610cfd565b82525050565b61098f81610d0f565b82525050565b60006109a082610c7d565b6109aa8185610ca4565b93506109ba818560208601610d54565b6109c381610e05565b840191505092915050565b60006109db602683610ca4565b91506109e682610e16565b604082019050919050565b60006109fe601d83610ca4565b9150610a0982610e65565b602082019050919050565b6000610a21602a83610ca4565b9150610a2c82610e8e565b604082019050919050565b6000610a44601f83610ca4565b9150610a4f82610edd565b602082019050919050565b610a6381610cf3565b82525050565b6000610a758284610946565b915081905092915050565b6000608082019050610a95600083018861090a565b610aa2602083018761090a565b610aaf6040830186610a5a565b8181036060830152610ac2818486610919565b90509695505050505050565b6000604082019050610ae3600083018561090a565b610af06020830184610a5a565b9392505050565b6000602082019050610b0c6000830184610977565b92915050565b6000602082019050610b276000830184610986565b92915050565b60006020820190508181036000830152610b478184610995565b905092915050565b60006020820190508181036000830152610b68816109ce565b9050919050565b60006020820190508181036000830152610b88816109f1565b9050919050565b60006020820190508181036000830152610ba881610a14565b9050919050565b60006020820190508181036000830152610bc881610a37565b9050919050565b6000602082019050610be46000830184610a5a565b92915050565b6000604082019050610bff6000830186610a5a565b8181036020830152610c12818486610919565b9050949350505050565b6000610c26610c37565b9050610c328282610d87565b919050565b6000604051905090565b600067ffffffffffffffff821115610c5c57610c5b610db8565b5b610c6582610e05565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610cc082610cd3565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610d0882610d21565b9050919050565b6000610d1a82610d21565b9050919050565b6000610d2c82610d33565b9050919050565b6000610d3e82610cd3565b9050919050565b82818337600083830152505050565b60005b83811015610d72578082015181840152602081019050610d57565b83811115610d81576000848401525b50505050565b610d9082610e05565b810181811067ffffffffffffffff82111715610daf57610dae610db8565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610f0f81610cb5565b8114610f1a57600080fd5b50565b610f2681610cc7565b8114610f3157600080fd5b50565b610f3d81610cf3565b8114610f4857600080fd5b5056fea264697066735822122032cd089b4d19023117d57080cfda5ef9528e168f0d215ac13c416f40b5c9daa164736f6c63430008070033", } // ZetaConnectorNewABI is the input ABI used to generate the binding from. diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index e2d3ab9b..490c2e54 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -604,7 +604,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "0x60a06040523073ffffffffffffffffffffffffffffffffffffffff1660809073ffffffffffffffffffffffffffffffffffffffff1660601b81525034801561004657600080fd5b5060805160601c6134e361008160003960008181610768015281816107f701528181610b2201528181610bb10152610fcd01526134e36000f3fe60806040526004361061011f5760003560e01c80635b112591116100a0578063dda79b7511610064578063dda79b7514610382578063f2fde38b146103ad578063f31e62bf146103d6578063f340fa0114610401578063f45346dc1461041d5761011f565b80635b112591146102c3578063715018a6146102ee5780638c6f037f146103055780638da5cb5b1461032e578063ae7a3a6f146103595761011f565b8063485cc955116100e7578063485cc955146101eb5780634f1ef286146102145780635131ab591461023057806352d1902d1461026d57806357bec62f146102985761011f565b806310188aef146101245780631b8b921d1461014d5780631cff79cd1461017657806329c59b5d146101a65780633659cfe6146101c2575b600080fd5b34801561013057600080fd5b5061014b6004803603810190610146919061244e565b610446565b005b34801561015957600080fd5b50610174600480360381019061016f9190612543565b610512565b005b610190600480360381019061018b9190612543565b61057e565b60405161019d9190612bd6565b60405180910390f35b6101c060048036038101906101bb9190612543565b6105ec565b005b3480156101ce57600080fd5b506101e960048036038101906101e4919061244e565b610766565b005b3480156101f757600080fd5b50610212600480360381019061020d919061247b565b6108ef565b005b61022e600480360381019061022991906125a3565b610b20565b005b34801561023c57600080fd5b50610257600480360381019061025291906124bb565b610c5d565b6040516102649190612bd6565b60405180910390f35b34801561027957600080fd5b50610282610fc9565b60405161028f9190612b97565b60405180910390f35b3480156102a457600080fd5b506102ad611082565b6040516102ba9190612af3565b60405180910390f35b3480156102cf57600080fd5b506102d86110a8565b6040516102e59190612af3565b60405180910390f35b3480156102fa57600080fd5b506103036110ce565b005b34801561031157600080fd5b5061032c60048036038101906103279190612652565b6110e2565b005b34801561033a57600080fd5b50610343611260565b6040516103509190612af3565b60405180910390f35b34801561036557600080fd5b50610380600480360381019061037b919061244e565b61128a565b005b34801561038e57600080fd5b50610397611356565b6040516103a49190612af3565b60405180910390f35b3480156103b957600080fd5b506103d460048036038101906103cf919061244e565b61137c565b005b3480156103e257600080fd5b506103eb611400565b6040516103f89190612af3565b60405180910390f35b61041b6004803603810190610416919061244e565b611426565b005b34801561042957600080fd5b50610444600480360381019061043f91906125ff565b61159a565b005b600073ffffffffffffffffffffffffffffffffffffffff1660cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146104ce576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060cb60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b8273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2a21062ee9199c2e205622999eeb7c3da73153674f36a0acd3f74fa6af67bde38484604051610571929190612bb2565b60405180910390a3505050565b6060600061058d858585611712565b90508473ffffffffffffffffffffffffffffffffffffffff167f373df382b9c587826f3de13f16d67f8d99f28ee947fc0924c6ef2d6d2c7e85463486866040516105d993929190612e51565b60405180910390a2809150509392505050565b6000341415610627576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163460405161066f90612ade565b60006040518083038185875af1925050503d80600081146106ac576040519150601f19603f3d011682016040523d82523d6000602084013e6106b1565b606091505b505090506000151581151514156106f4576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600087876040516107589493929190612dd5565b60405180910390a350505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614156107f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107ec90612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166108346117c9565b73ffffffffffffffffffffffffffffffffffffffff161461088a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161088190612c75565b60405180910390fd5b61089381611820565b6108ec81600067ffffffffffffffff8111156108b2576108b1613012565b5b6040519080825280601f01601f1916602001820160405280156108e45781602001600182028036833780820191505090505b50600061182b565b50565b60008060019054906101000a900460ff161590508080156109205750600160008054906101000a900460ff1660ff16105b8061094d575061092f306119a8565b15801561094c5750600160008054906101000a900460ff1660ff16145b5b61098c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161098390612cf5565b60405180910390fd5b60016000806101000a81548160ff021916908360ff16021790555080156109c9576001600060016101000a81548160ff0219169083151502179055505b6109d16119cb565b6109d9611a24565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610a40576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8260ca60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508160cc60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508015610b1b5760008060016101000a81548160ff0219169083151502179055507f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024986001604051610b129190612bf8565b60405180910390a15b505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff161415610baf576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ba690612c55565b60405180910390fd5b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16610bee6117c9565b73ffffffffffffffffffffffffffffffffffffffff1614610c44576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610c3b90612c75565b60405180910390fd5b610c4d82611820565b610c598282600161182b565b5050565b60606000841415610c9a576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b610ca48686611a75565b610cda576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8573ffffffffffffffffffffffffffffffffffffffff1663095ea7b386866040518363ffffffff1660e01b8152600401610d15929190612b6e565b602060405180830381600087803b158015610d2f57600080fd5b505af1158015610d43573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d6791906126da565b610d9d576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6000610daa868585611712565b9050610db68787611a75565b610dec576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008773ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610e279190612af3565b60206040518083038186803b158015610e3f57600080fd5b505afa158015610e53573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e779190612734565b90506000811115610f5257600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168973ffffffffffffffffffffffffffffffffffffffff161415610f255760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b610f5081838b73ffffffffffffffffffffffffffffffffffffffff16611b0d9092919063ffffffff16565b505b8673ffffffffffffffffffffffffffffffffffffffff168873ffffffffffffffffffffffffffffffffffffffff167f29c40793bffd84cb810179f15d1ceec72bc7f0785514c668ba36645cf99b7382888888604051610fb393929190612e51565b60405180910390a3819250505095945050505050565b60007f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff163073ffffffffffffffffffffffffffffffffffffffff1614611059576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161105090612cb5565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b905090565b60cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6110d6611b93565b6110e06000611c11565b565b600084141561111d576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff1614156111c05760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6111ed3382878773ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8573ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a4878787876040516112509493929190612dd5565b60405180910390a3505050505050565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600073ffffffffffffffffffffffffffffffffffffffff1660c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614611312576040517fb337f37800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8060c960006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b611384611b93565b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156113f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016113eb90612c35565b60405180910390fd5b6113fd81611c11565b50565b60cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000341415611461576040517f7671265e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060ca60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16346040516114a990612ade565b60006040518083038185875af1925050503d80600081146114e6576040519150601f19603f3d011682016040523d82523d6000602084013e6114eb565b606091505b5050905060001515811515141561152e576040517f79cacff100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a434600060405161158e929190612e15565b60405180910390a35050565b60008214156115d5576040517f951e19ed00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b600060c960009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060cc60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156116785760cb60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690505b6116a53382858573ffffffffffffffffffffffffffffffffffffffff16611cd7909392919063ffffffff16565b8373ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f2103daedac6c1eee9e5bfbd02064d751c9ec3c03fb9bc3e4f94ca41afa38c1a48585604051611704929190612e15565b60405180910390a350505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff1634868660405161173f929190612aae565b60006040518083038185875af1925050503d806000811461177c576040519150601f19603f3d011682016040523d82523d6000602084013e611781565b606091505b5091509150816117bd576040517facfdb44400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80925050509392505050565b60006117f77f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b611828611b93565b50565b6118577f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd914360001b611d6a565b60000160009054906101000a900460ff161561187b5761187683611d74565b6119a3565b8273ffffffffffffffffffffffffffffffffffffffff166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b1580156118c157600080fd5b505afa9250505080156118f257506040513d601f19601f820116820180604052508101906118ef9190612707565b60015b611931576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161192890612d15565b60405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b8114611996576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161198d90612cd5565b60405180910390fd5b506119a2838383611e2d565b5b505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b600060019054906101000a900460ff16611a1a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a1190612d95565b60405180910390fd5b611a22611e59565b565b600060019054906101000a900460ff16611a73576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611a6a90612d95565b60405180910390fd5b565b60008273ffffffffffffffffffffffffffffffffffffffff1663095ea7b38360006040518363ffffffff1660e01b8152600401611ab3929190612b45565b602060405180830381600087803b158015611acd57600080fd5b505af1158015611ae1573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b0591906126da565b905092915050565b611b8e8363a9059cbb60e01b8484604051602401611b2c929190612b6e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b505050565b611b9b611f81565b73ffffffffffffffffffffffffffffffffffffffff16611bb9611260565b73ffffffffffffffffffffffffffffffffffffffff1614611c0f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611c0690612d55565b60405180910390fd5b565b6000603360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905081603360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b611d5a846323b872dd60e01b858585604051602401611cf893929190612b0e565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050611eba565b50505050565b6000819050919050565b6000819050919050565b611d7d816119a8565b611dbc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611db390612d35565b60405180910390fd5b80611de97f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b611d60565b60000160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b611e3683611f89565b600082511180611e435750805b15611e5457611e528383611fd8565b505b505050565b600060019054906101000a900460ff16611ea8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611e9f90612d95565b60405180910390fd5b611eb8611eb3611f81565b611c11565b565b6000611f1c826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166120059092919063ffffffff16565b9050600081511115611f7c5780806020019051810190611f3c91906126da565b611f7b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611f7290612db5565b60405180910390fd5b5b505050565b600033905090565b611f9281611d74565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b6060611ffd83836040518060600160405280602781526020016134876027913961201d565b905092915050565b606061201484846000856120a3565b90509392505050565b60606000808573ffffffffffffffffffffffffffffffffffffffff16856040516120479190612ac7565b600060405180830381855af49150503d8060008114612082576040519150601f19603f3d011682016040523d82523d6000602084013e612087565b606091505b509150915061209886838387612170565b925050509392505050565b6060824710156120e8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016120df90612c95565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516121119190612ac7565b60006040518083038185875af1925050503d806000811461214e576040519150601f19603f3d011682016040523d82523d6000602084013e612153565b606091505b5091509150612164878383876121e6565b92505050949350505050565b606083156121d3576000835114156121cb5761218b856119a8565b6121ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121c190612d75565b60405180910390fd5b5b8290506121de565b6121dd838361225c565b5b949350505050565b606083156122495760008351141561224157612201856122ac565b612240576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161223790612d75565b60405180910390fd5b5b829050612254565b61225383836122cf565b5b949350505050565b60008251111561226f5781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122a39190612c13565b60405180910390fd5b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156122e25781518083602001fd5b806040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016123169190612c13565b60405180910390fd5b600061233261232d84612ea8565b612e83565b90508281526020810184848401111561234e5761234d613050565b5b612359848285612f9f565b509392505050565b6000813590506123708161342a565b92915050565b60008151905061238581613441565b92915050565b60008151905061239a81613458565b92915050565b60008083601f8401126123b6576123b5613046565b5b8235905067ffffffffffffffff8111156123d3576123d2613041565b5b6020830191508360018202830111156123ef576123ee61304b565b5b9250929050565b600082601f83011261240b5761240a613046565b5b813561241b84826020860161231f565b91505092915050565b6000813590506124338161346f565b92915050565b6000815190506124488161346f565b92915050565b6000602082840312156124645761246361305a565b5b600061247284828501612361565b91505092915050565b600080604083850312156124925761249161305a565b5b60006124a085828601612361565b92505060206124b185828601612361565b9150509250929050565b6000806000806000608086880312156124d7576124d661305a565b5b60006124e588828901612361565b95505060206124f688828901612361565b945050604061250788828901612424565b935050606086013567ffffffffffffffff81111561252857612527613055565b5b612534888289016123a0565b92509250509295509295909350565b60008060006040848603121561255c5761255b61305a565b5b600061256a86828701612361565b935050602084013567ffffffffffffffff81111561258b5761258a613055565b5b612597868287016123a0565b92509250509250925092565b600080604083850312156125ba576125b961305a565b5b60006125c885828601612361565b925050602083013567ffffffffffffffff8111156125e9576125e8613055565b5b6125f5858286016123f6565b9150509250929050565b6000806000606084860312156126185761261761305a565b5b600061262686828701612361565b935050602061263786828701612424565b925050604061264886828701612361565b9150509250925092565b60008060008060006080868803121561266e5761266d61305a565b5b600061267c88828901612361565b955050602061268d88828901612424565b945050604061269e88828901612361565b935050606086013567ffffffffffffffff8111156126bf576126be613055565b5b6126cb888289016123a0565b92509250509295509295909350565b6000602082840312156126f0576126ef61305a565b5b60006126fe84828501612376565b91505092915050565b60006020828403121561271d5761271c61305a565b5b600061272b8482850161238b565b91505092915050565b60006020828403121561274a5761274961305a565b5b600061275884828501612439565b91505092915050565b61276a81612f1c565b82525050565b61277981612f3a565b82525050565b600061278b8385612eef565b9350612798838584612f9f565b6127a18361305f565b840190509392505050565b60006127b88385612f00565b93506127c5838584612f9f565b82840190509392505050565b60006127dc82612ed9565b6127e68185612eef565b93506127f6818560208601612fae565b6127ff8161305f565b840191505092915050565b600061281582612ed9565b61281f8185612f00565b935061282f818560208601612fae565b80840191505092915050565b61284481612f7b565b82525050565b61285381612f8d565b82525050565b600061286482612ee4565b61286e8185612f0b565b935061287e818560208601612fae565b6128878161305f565b840191505092915050565b600061289f602683612f0b565b91506128aa82613070565b604082019050919050565b60006128c2602c83612f0b565b91506128cd826130bf565b604082019050919050565b60006128e5602c83612f0b565b91506128f08261310e565b604082019050919050565b6000612908602683612f0b565b91506129138261315d565b604082019050919050565b600061292b603883612f0b565b9150612936826131ac565b604082019050919050565b600061294e602983612f0b565b9150612959826131fb565b604082019050919050565b6000612971602e83612f0b565b915061297c8261324a565b604082019050919050565b6000612994602e83612f0b565b915061299f82613299565b604082019050919050565b60006129b7602d83612f0b565b91506129c2826132e8565b604082019050919050565b60006129da602083612f0b565b91506129e582613337565b602082019050919050565b60006129fd600083612eef565b9150612a0882613360565b600082019050919050565b6000612a20600083612f00565b9150612a2b82613360565b600082019050919050565b6000612a43601d83612f0b565b9150612a4e82613363565b602082019050919050565b6000612a66602b83612f0b565b9150612a718261338c565b604082019050919050565b6000612a89602a83612f0b565b9150612a94826133db565b604082019050919050565b612aa881612f64565b82525050565b6000612abb8284866127ac565b91508190509392505050565b6000612ad3828461280a565b915081905092915050565b6000612ae982612a13565b9150819050919050565b6000602082019050612b086000830184612761565b92915050565b6000606082019050612b236000830186612761565b612b306020830185612761565b612b3d6040830184612a9f565b949350505050565b6000604082019050612b5a6000830185612761565b612b67602083018461283b565b9392505050565b6000604082019050612b836000830185612761565b612b906020830184612a9f565b9392505050565b6000602082019050612bac6000830184612770565b92915050565b60006020820190508181036000830152612bcd81848661277f565b90509392505050565b60006020820190508181036000830152612bf081846127d1565b905092915050565b6000602082019050612c0d600083018461284a565b92915050565b60006020820190508181036000830152612c2d8184612859565b905092915050565b60006020820190508181036000830152612c4e81612892565b9050919050565b60006020820190508181036000830152612c6e816128b5565b9050919050565b60006020820190508181036000830152612c8e816128d8565b9050919050565b60006020820190508181036000830152612cae816128fb565b9050919050565b60006020820190508181036000830152612cce8161291e565b9050919050565b60006020820190508181036000830152612cee81612941565b9050919050565b60006020820190508181036000830152612d0e81612964565b9050919050565b60006020820190508181036000830152612d2e81612987565b9050919050565b60006020820190508181036000830152612d4e816129aa565b9050919050565b60006020820190508181036000830152612d6e816129cd565b9050919050565b60006020820190508181036000830152612d8e81612a36565b9050919050565b60006020820190508181036000830152612dae81612a59565b9050919050565b60006020820190508181036000830152612dce81612a7c565b9050919050565b6000606082019050612dea6000830187612a9f565b612df76020830186612761565b8181036040830152612e0a81848661277f565b905095945050505050565b6000606082019050612e2a6000830185612a9f565b612e376020830184612761565b8181036040830152612e48816129f0565b90509392505050565b6000604082019050612e666000830186612a9f565b8181036020830152612e7981848661277f565b9050949350505050565b6000612e8d612e9e565b9050612e998282612fe1565b919050565b6000604051905090565b600067ffffffffffffffff821115612ec357612ec2613012565b5b612ecc8261305f565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000612f2782612f44565b9050919050565b60008115159050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b600060ff82169050919050565b6000612f8682612f64565b9050919050565b6000612f9882612f6e565b9050919050565b82818337600083830152505050565b60005b83811015612fcc578082015181840152602081019050612fb1565b83811115612fdb576000848401525b50505050565b612fea8261305f565b810181811067ffffffffffffffff8211171561300957613008613012565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f64656c656761746563616c6c0000000000000000000000000000000000000000602082015250565b7f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060008201527f6163746976652070726f78790000000000000000000000000000000000000000602082015250565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f555550535570677261646561626c653a206d757374206e6f742062652063616c60008201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000602082015250565b7f45524331393637557067726164653a20756e737570706f727465642070726f7860008201527f6961626c65555549440000000000000000000000000000000000000000000000602082015250565b7f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160008201527f647920696e697469616c697a6564000000000000000000000000000000000000602082015250565b7f45524331393637557067726164653a206e657720696d706c656d656e7461746960008201527f6f6e206973206e6f742055555053000000000000000000000000000000000000602082015250565b7f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60008201527f6f74206120636f6e747261637400000000000000000000000000000000000000602082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b50565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960008201527f6e697469616c697a696e67000000000000000000000000000000000000000000602082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b61343381612f1c565b811461343e57600080fd5b50565b61344a81612f2e565b811461345557600080fd5b50565b61346181612f3a565b811461346c57600080fd5b50565b61347881612f64565b811461348357600080fd5b5056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212203ccfd9aebdbc92b9cc4a06ca3a81aa789e3179bce1baa12b5c4f13b5d77ae5df64736f6c63430008070033"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 566653c8..e039fd9b 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -579,7 +579,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts index 3c19e1c1..eea00da8 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts @@ -145,7 +145,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ZetaConnectorNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 304fba02..8bc18ce2 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -368,6 +368,10 @@ declare module "hardhat/types/runtime" { name: "TestERC20", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "ZetaConnectorNew", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -914,6 +918,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "ZetaConnectorNew", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "GatewayZEVM", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 48c348e9..d37c2b01 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -174,6 +174,8 @@ export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; +export type { ZetaConnectorNew } from "./contracts/prototypes/evm/ZetaConnectorNew"; +export { ZetaConnectorNew__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNew__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; From 09e5d90b1abf96c3c21a9ce39106789f72f3d02b Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 17 Jul 2024 17:37:22 +0200 Subject: [PATCH 79/86] fix tests --- contracts/prototypes/evm/GatewayEVMUpgradeTest.sol | 12 ++++++------ testFoundry/GatewayEVM.t.sol | 11 ++++++++--- testFoundry/GatewayEVMUpgrade.t.sol | 8 +++++++- testFoundry/GatewayEVMZEVM.t.sol | 10 +++++++++- testFoundry/GatewayZEVM.t.sol | 4 ++-- 5 files changed, 32 insertions(+), 13 deletions(-) diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index f4736206..bfdf7e5c 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -18,20 +18,20 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade address public custody; address public tssAddress; address public zetaConnector; - address public zetaAsset; + address public zeta; event ExecutedV2(address indexed destination, uint256 value, bytes data); constructor() {} - function initialize(address _tssAddress, address _zetaAsset) public initializer { + function initialize(address _tssAddress, address _zeta) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); if (_tssAddress == address(0)) revert ZeroAddress(); tssAddress = _tssAddress; - zetaAsset = _zetaAsset; + zeta = _zeta; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -80,7 +80,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { address destination = address(custody); - if (token == zetaAsset) { + if (token == zeta) { destination = address(zetaConnector); } IERC20(token).safeTransfer(address(destination), remainingBalance); @@ -106,7 +106,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zetaAsset) { + if (asset == zeta) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); @@ -129,7 +129,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zetaAsset) { + if (asset == zeta) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); diff --git a/testFoundry/GatewayEVM.t.sol b/testFoundry/GatewayEVM.t.sol index 0e27128a..877ba316 100644 --- a/testFoundry/GatewayEVM.t.sol +++ b/testFoundry/GatewayEVM.t.sol @@ -42,7 +42,7 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver proxy = address(new ERC1967Proxy( address(new GatewayEVM()), - abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress, zeta)) + abi.encodeWithSelector(GatewayEVM.initialize.selector, tssAddress, address(zeta)) )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); @@ -180,7 +180,9 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR GatewayEVM gateway; ERC20CustodyNew custody; + ZetaConnectorNew zetaConnector; TestERC20 token; + TestERC20 zeta; address owner; address destination; address tssAddress; @@ -193,14 +195,17 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR tssAddress = address(0x5678); token = new TestERC20("test", "TTK"); - address proxy = address(new ERC1967Proxy( + zeta = new TestERC20("zeta", "ZETA"); + address proxy = address(new ERC1967Proxy( address(new GatewayEVM()), - abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress)) + abi.encodeWithSelector(GatewayEVM.initialize.selector, tssAddress, address(zeta)) )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); + zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); gateway.setCustody(address(custody)); + gateway.setConnector(address(zetaConnector)); token.mint(owner, ownerAmount); } diff --git a/testFoundry/GatewayEVMUpgrade.t.sol b/testFoundry/GatewayEVMUpgrade.t.sol index e751c4df..fa3a1879 100644 --- a/testFoundry/GatewayEVMUpgrade.t.sol +++ b/testFoundry/GatewayEVMUpgrade.t.sol @@ -8,6 +8,7 @@ import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/GatewayEVMUpgradeTest.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -23,7 +24,9 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; + ZetaConnectorNew zetaConnector; TestERC20 token; + TestERC20 zeta; address owner; address destination; address tssAddress; @@ -34,17 +37,20 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents tssAddress = address(0x5678); token = new TestERC20("test", "TTK"); + zeta = new TestERC20("zeta", "ZETA"); proxy = address(new ERC1967Proxy( address(new GatewayEVM()), - abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress)) + abi.encodeWithSelector(GatewayEVM.initialize.selector, tssAddress, zeta) )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); + zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); + gateway.setConnector(address(zetaConnector)); token.mint(owner, 1000000); token.transfer(address(custody), 500000); diff --git a/testFoundry/GatewayEVMZEVM.t.sol b/testFoundry/GatewayEVMZEVM.t.sol index 4bc11c8d..8e1044bd 100644 --- a/testFoundry/GatewayEVMZEVM.t.sol +++ b/testFoundry/GatewayEVMZEVM.t.sol @@ -7,6 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNew.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; @@ -29,7 +30,9 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate address proxyEVM; GatewayEVM gatewayEVM; ERC20CustodyNew custody; + ZetaConnectorNew zetaConnector; TestERC20 token; + TestERC20 zeta; ReceiverEVM receiverEVM; address ownerEVM; address destination; @@ -51,14 +54,18 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate ownerZEVM = address(0x4321); token = new TestERC20("test", "TTK"); + zeta = new TestERC20("zeta", "ZETA"); + proxyEVM = address(new ERC1967Proxy( address(new GatewayEVM()), - abi.encodeWithSelector(GatewayEVM.initialize.selector, (tssAddress)) + abi.encodeWithSelector(GatewayEVM.initialize.selector, tssAddress, address(zeta)) )); gatewayEVM = GatewayEVM(proxyEVM); custody = new ERC20CustodyNew(address(gatewayEVM)); + zetaConnector = new ZetaConnectorNew(address(gatewayEVM), address(zeta)); gatewayEVM.setCustody(address(custody)); + gatewayEVM.setConnector(address(zetaConnector)); token.mint(ownerEVM, 1000000); token.transfer(address(custody), 500000); @@ -139,6 +146,7 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate vm.expectEmit(true, true, true, true, address(gatewayZEVM)); emit Withdrawal( ownerZEVM, + address(zrc20), abi.encodePacked(receiverEVM), 1000000, 0, diff --git a/testFoundry/GatewayZEVM.t.sol b/testFoundry/GatewayZEVM.t.sol index 60d33da1..f52b5194 100644 --- a/testFoundry/GatewayZEVM.t.sol +++ b/testFoundry/GatewayZEVM.t.sol @@ -51,7 +51,7 @@ contract GatewayZEVMInboundTest is Test, IGatewayZEVMEvents, IGatewayZEVMErrors uint256 ownerBalanceBefore = zrc20.balanceOf(owner); vm.expectEmit(true, true, true, true, address(gateway)); - emit Withdrawal(owner, abi.encodePacked(addr1), 1, 0, zrc20.PROTOCOL_FLAT_FEE(), ""); + emit Withdrawal(owner, address(zrc20), abi.encodePacked(addr1), 1, 0, zrc20.PROTOCOL_FLAT_FEE(), ""); gateway.withdraw(abi.encodePacked(addr1), 1, address(zrc20)); uint256 ownerBalanceAfter = zrc20.balanceOf(owner); @@ -63,7 +63,7 @@ contract GatewayZEVMInboundTest is Test, IGatewayZEVMEvents, IGatewayZEVMErrors bytes memory message = abi.encodeWithSignature("hello(address)", addr1); vm.expectEmit(true, true, true, true, address(gateway)); - emit Withdrawal(owner, abi.encodePacked(addr1), 1, 0, zrc20.PROTOCOL_FLAT_FEE(), message); + emit Withdrawal(owner, address(zrc20), abi.encodePacked(addr1), 1, 0, zrc20.PROTOCOL_FLAT_FEE(), message); gateway.withdrawAndCall(abi.encodePacked(addr1), 1, address(zrc20), message); uint256 ownerBalanceAfter = zrc20.balanceOf(owner); From deee4d30a4ce046dcafeb87b2b5f2d58ddcbef2f Mon Sep 17 00:00:00 2001 From: skosito Date: Wed, 17 Jul 2024 17:39:06 +0200 Subject: [PATCH 80/86] generate --- .../gatewayevmupgradetest.go | 46 +++++++++---------- .../prototypes/evm/GatewayEVMUpgradeTest.ts | 28 +++++------ .../evm/GatewayEVMUpgradeTest__factory.ts | 6 +-- 3 files changed, 40 insertions(+), 40 deletions(-) diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index 49719dc3..1bcb2b99 100644 --- a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -31,8 +31,8 @@ var ( // GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaAsset\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaAsset\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. @@ -326,12 +326,12 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) TssAddress() ( return _GatewayEVMUpgradeTest.Contract.TssAddress(&_GatewayEVMUpgradeTest.CallOpts) } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaAsset(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zeta() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaAsset") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zeta") if err != nil { return *new(common.Address), err @@ -343,18 +343,18 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaAsset(opts *bind. } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaAsset() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.ZetaAsset(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zeta() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Zeta() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Zeta(&_GatewayEVMUpgradeTest.CallOpts) } -// ZetaAsset is a free data retrieval call binding the contract method 0xf31e62bf. +// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. // -// Solidity: function zetaAsset() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaAsset() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.ZetaAsset(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zeta() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) Zeta() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.Zeta(&_GatewayEVMUpgradeTest.CallOpts) } // ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. @@ -537,23 +537,23 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) ExecuteWit // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress, _zeta) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zeta) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zetaAsset) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address, _zetaAsset common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaAsset) +// Solidity: function initialize(address _tssAddress, address _zeta) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zeta) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts index 9cb10767..f38ef42e 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts @@ -48,7 +48,7 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; - "zetaAsset()": FunctionFragment; + "zeta()": FunctionFragment; "zetaConnector()": FunctionFragment; }; @@ -72,7 +72,7 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { | "tssAddress" | "upgradeTo" | "upgradeToAndCall" - | "zetaAsset" + | "zeta" | "zetaConnector" ): FunctionFragment; @@ -156,7 +156,7 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; - encodeFunctionData(functionFragment: "zetaAsset", values?: undefined): string; + encodeFunctionData(functionFragment: "zeta", values?: undefined): string; encodeFunctionData( functionFragment: "zetaConnector", values?: undefined @@ -210,7 +210,7 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "zetaAsset", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; decodeFunctionResult( functionFragment: "zetaConnector", data: BytesLike @@ -426,7 +426,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -466,7 +466,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise<[string]>; + zeta(overrides?: CallOverrides): Promise<[string]>; zetaConnector(overrides?: CallOverrides): Promise<[string]>; }; @@ -521,7 +521,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -561,7 +561,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; @@ -616,7 +616,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -654,7 +654,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: CallOverrides ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; @@ -808,7 +808,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -848,7 +848,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; @@ -904,7 +904,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zetaAsset: PromiseOrValue, + _zeta: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -944,7 +944,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zetaAsset(overrides?: CallOverrides): Promise; + zeta(overrides?: CallOverrides): Promise; zetaConnector(overrides?: CallOverrides): Promise; }; diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index 490c2e54..8b8846f6 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -450,7 +450,7 @@ const _abi = [ }, { internalType: "address", - name: "_zetaAsset", + name: "_zeta", type: "address", }, ], @@ -577,7 +577,7 @@ const _abi = [ }, { inputs: [], - name: "zetaAsset", + name: "zeta", outputs: [ { internalType: "address", @@ -604,7 +604,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] From 572646b1ad70d77f7539b9597658cc491bf3a890 Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 18 Jul 2024 16:43:34 +0200 Subject: [PATCH 81/86] PR comments --- contracts/prototypes/evm/ERC20CustodyNew.sol | 2 +- contracts/prototypes/evm/GatewayEVM.sol | 55 ++++++++++--------- .../prototypes/evm/GatewayEVMUpgradeTest.sol | 14 ++--- .../evm/{interfaces.sol => IGatewayEVM.sol} | 9 +-- contracts/prototypes/evm/IReceiverEVM.sol | 9 +++ contracts/prototypes/evm/ZetaConnectorNew.sol | 24 ++++---- contracts/prototypes/zevm/GatewayZEVM.sol | 27 ++++----- .../zevm/{interfaces.sol => IGatewayZEVM.sol} | 2 +- contracts/prototypes/zevm/SenderZEVM.sol | 2 +- testFoundry/GatewayEVM.t.sol | 3 +- testFoundry/GatewayEVMUpgrade.t.sol | 3 +- testFoundry/GatewayEVMZEVM.t.sol | 5 +- testFoundry/GatewayZEVM.t.sol | 2 +- 13 files changed, 84 insertions(+), 73 deletions(-) rename contracts/prototypes/evm/{interfaces.sol => IGatewayEVM.sol} (71%) create mode 100644 contracts/prototypes/evm/IReceiverEVM.sol rename contracts/prototypes/zevm/{interfaces.sol => IGatewayZEVM.sol} (97%) diff --git a/contracts/prototypes/evm/ERC20CustodyNew.sol b/contracts/prototypes/evm/ERC20CustodyNew.sol index 0b0ec3f2..be8933d9 100644 --- a/contracts/prototypes/evm/ERC20CustodyNew.sol +++ b/contracts/prototypes/evm/ERC20CustodyNew.sol @@ -2,7 +2,7 @@ pragma solidity ^0.8.0; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./interfaces.sol"; +import "./IGatewayEVM.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 6da3f73e..68d2e49b 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -6,33 +6,43 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; -import "./interfaces.sol"; +import "./IGatewayEVM.sol"; -// The GatewayEVM contract is the endpoint to call smart contracts on external chains -// The contract doesn't hold any funds and should never have active allowances +/** + * @title GatewayEVM + * @notice The GatewayEVM contract is the endpoint to call smart contracts on external chains. + * @dev The contract doesn't hold any funds and should never have active allowances. + */ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGatewayEVMErrors, IGatewayEVMEvents { using SafeERC20 for IERC20; + /// @notice The address of the custody contract. address public custody; + + /// @notice The address of the TSS (Threshold Signature Scheme) contract. address public tssAddress; + + /// @notice The address of the ZetaConnector contract. address public zetaConnector; - address public zeta; + + /// @notice The address of the Zeta token contract. + address public zetaToken; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } - function initialize(address _tssAddress, address _zeta) public initializer { + function initialize(address _tssAddress, address _zetaToken) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); - if (_tssAddress == address(0) || _zeta == address(0)) { + if (_tssAddress == address(0) || _zetaToken == address(0)) { revert ZeroAddress(); } tssAddress = _tssAddress; - zeta = _zeta; + zetaToken = _zetaToken; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -64,7 +74,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate address to, uint256 amount, bytes calldata data - ) public returns (bytes memory) { + ) public { if (amount == 0) revert InsufficientETHAmount(); // Approve the target contract to spend the tokens if(!resetApproval(token, to)) revert ApprovalFailed(); @@ -79,16 +89,10 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Transfer any remaining tokens back to the custody/connector contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - address destination = address(custody); - if (token == zeta) { - destination = address(zetaConnector); - } - IERC20(token).safeTransfer(address(destination), remainingBalance); + IERC20(token).safeTransfer(getAssetHandler(token), remainingBalance); } emit ExecutedWithERC20(token, to, amount, data); - - return result; } // Deposit ETH to tss @@ -105,11 +109,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); - address destination = address(custody); - if (asset == zeta) { - destination = address(zetaConnector); - } - IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); + IERC20(asset).safeTransferFrom(msg.sender, getAssetHandler(asset), amount); emit Deposit(msg.sender, receiver, amount, asset, ""); } @@ -128,11 +128,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); - address destination = address(custody); - if (asset == zeta) { - destination = address(zetaConnector); - } - IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); + IERC20(asset).safeTransferFrom(msg.sender, getAssetHandler(asset), amount); emit Deposit(msg.sender, receiver, amount, asset, payload); } @@ -159,4 +155,13 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function resetApproval(address token, address to) private returns (bool) { return IERC20(token).approve(to, 0); } + + function getAssetHandler(address token) private returns (address) { + address assetHandler = address(custody); + if (token == zetaToken) { + assetHandler = address(zetaConnector); + } + + return assetHandler; + } } diff --git a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol index bfdf7e5c..377eceae 100644 --- a/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol +++ b/contracts/prototypes/evm/GatewayEVMUpgradeTest.sol @@ -6,7 +6,7 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; -import "./interfaces.sol"; +import "./IGatewayEVM.sol"; // NOTE: Purpose of this contract is to test upgrade process, the only difference should be name of Executed event // The Gateway contract is the endpoint to call smart contracts on external chains @@ -18,20 +18,20 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade address public custody; address public tssAddress; address public zetaConnector; - address public zeta; + address public zetaToken; event ExecutedV2(address indexed destination, uint256 value, bytes data); constructor() {} - function initialize(address _tssAddress, address _zeta) public initializer { + function initialize(address _tssAddress, address _zetaToken) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); if (_tssAddress == address(0)) revert ZeroAddress(); tssAddress = _tssAddress; - zeta = _zeta; + zetaToken = _zetaToken; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -80,7 +80,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { address destination = address(custody); - if (token == zeta) { + if (token == zetaToken) { destination = address(zetaConnector); } IERC20(token).safeTransfer(address(destination), remainingBalance); @@ -106,7 +106,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zeta) { + if (asset == zetaToken) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); @@ -129,7 +129,7 @@ contract GatewayEVMUpgradeTest is Initializable, OwnableUpgradeable, UUPSUpgrade if (amount == 0) revert InsufficientERC20Amount(); address destination = address(custody); - if (asset == zeta) { + if (asset == zetaToken) { destination = address(zetaConnector); } IERC20(asset).safeTransferFrom(msg.sender, address(destination), amount); diff --git a/contracts/prototypes/evm/interfaces.sol b/contracts/prototypes/evm/IGatewayEVM.sol similarity index 71% rename from contracts/prototypes/evm/interfaces.sol rename to contracts/prototypes/evm/IGatewayEVM.sol index 9f89c877..ba5d4384 100644 --- a/contracts/prototypes/evm/interfaces.sol +++ b/contracts/prototypes/evm/IGatewayEVM.sol @@ -18,20 +18,13 @@ interface IGatewayEVMErrors { error CustodyInitialized(); } -interface IReceiverEVMEvents { - event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag); - event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag); - event ReceivedERC20(address sender, uint256 amount, address token, address destination); - event ReceivedNoParams(address sender); -} - interface IGatewayEVM { function executeWithERC20( address token, address to, uint256 amount, bytes calldata data - ) external returns (bytes memory); + ) external; function execute(address destination, bytes calldata data) external payable returns (bytes memory); } \ No newline at end of file diff --git a/contracts/prototypes/evm/IReceiverEVM.sol b/contracts/prototypes/evm/IReceiverEVM.sol new file mode 100644 index 00000000..41a6285b --- /dev/null +++ b/contracts/prototypes/evm/IReceiverEVM.sol @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +interface IReceiverEVMEvents { + event ReceivedPayable(address sender, uint256 value, string str, uint256 num, bool flag); + event ReceivedNonPayable(address sender, string[] strs, uint256[] nums, bool flag); + event ReceivedERC20(address sender, uint256 amount, address token, address destination); + event ReceivedNoParams(address sender); +} diff --git a/contracts/prototypes/evm/ZetaConnectorNew.sol b/contracts/prototypes/evm/ZetaConnectorNew.sol index d7724405..b9e38d9e 100644 --- a/contracts/prototypes/evm/ZetaConnectorNew.sol +++ b/contracts/prototypes/evm/ZetaConnectorNew.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./interfaces.sol"; +import "./IGatewayEVM.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; @@ -11,40 +11,40 @@ contract ZetaConnectorNew is ReentrancyGuard{ error ZeroAddress(); IGatewayEVM public immutable gateway; - IERC20 public immutable zeta; + IERC20 public immutable zetaToken; event Withdraw(address indexed to, uint256 amount); event WithdrawAndCall(address indexed to, uint256 amount, bytes data); - constructor(address _gateway, address _zeta) { - if (_gateway == address(0) || _zeta == address(0)) { + constructor(address _gateway, address _zetaToken) { + if (_gateway == address(0) || _zetaToken == address(0)) { revert ZeroAddress(); } gateway = IGatewayEVM(_gateway); - zeta = IERC20(_zeta); + zetaToken = IERC20(_zetaToken); } - // Withdraw is called by TSS address, it directly transfers zeta to the destination address without contract call + // Withdraw is called by TSS address, it directly transfers zetaToken to the destination address without contract call // TODO: Finalize access control // https://github.com/zeta-chain/protocol-contracts/issues/204 function withdraw(address to, uint256 amount) external nonReentrant { // TODO: mint? - zeta.safeTransfer(to, amount); + zetaToken.safeTransfer(to, amount); emit Withdraw(to, amount); } - // WithdrawAndCall is called by TSS address, it transfers zeta and call a contract - // For this, it passes through the Gateway contract, it transfers zeta to the Gateway contract and then calls the contract + // WithdrawAndCall is called by TSS address, it transfers zetaToken and call a contract + // For this, it passes through the Gateway contract, it transfers zetaToken to the Gateway contract and then calls the contract // TODO: Finalize access control // https://github.com/zeta-chain/protocol-contracts/issues/204 function withdrawAndCall(address to, uint256 amount, bytes calldata data) public nonReentrant { // TODO: mint? - // Transfer zeta to the Gateway contract - zeta.safeTransfer(address(gateway), amount); + // Transfer zetaToken to the Gateway contract + zetaToken.safeTransfer(address(gateway), amount); // Forward the call to the Gateway contract - gateway.executeWithERC20(address(zeta), to, amount, data); + gateway.executeWithERC20(address(zetaToken), to, amount, data); emit WithdrawAndCall(to, amount, data); } diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index 48fba375..fa534a58 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -4,27 +4,28 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; import "../../zevm/interfaces/IZRC20.sol"; import "../../zevm/interfaces/zContract.sol"; -import "./interfaces.sol"; +import "./IGatewayZEVM.sol"; import "../../zevm/interfaces/IWZETA.sol"; // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances -contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, OwnableUpgradeable, UUPSUpgradeable { +contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, OwnableUpgradeable, UUPSUpgradeable, ReentrancyGuard { address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; - address public wzeta; + address public zetaToken; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } - function initialize(address _wzeta) public initializer { + function initialize(address _zetaToken) public initializer { __Ownable_init(); __UUPSUpgradeable_init(); - wzeta = _wzeta; + zetaToken = _zetaToken; } function _authorizeUpgrade(address newImplementation) internal override onlyOwner() {} @@ -45,38 +46,38 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O } function _transferZETA(uint256 amount, address to) internal { - if (!IWETH9(wzeta).transferFrom(msg.sender, address(this), amount)) revert WZETATransferFailed(); - IWETH9(wzeta).withdraw(amount); + if (!IWETH9(zetaToken).transferFrom(msg.sender, address(this), amount)) revert ZetaTokenTransferFailed(); + IWETH9(zetaToken).withdraw(amount); (bool sent, ) = to.call{value: amount}(""); if (!sent) revert FailedZetaSent(); } // Withdraw ZRC20 tokens to external chain - function withdraw(bytes memory receiver, uint256 amount, address zrc20) external { + function withdraw(bytes memory receiver, uint256 amount, address zrc20) external nonReentrant { uint256 gasFee = _withdrawZRC20(amount, zrc20); emit Withdrawal(msg.sender, zrc20, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), ""); } // Withdraw ZRC20 tokens and call smart contract on external chain - function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external { + function withdrawAndCall(bytes memory receiver, uint256 amount, address zrc20, bytes calldata message) external nonReentrant { uint256 gasFee = _withdrawZRC20(amount, zrc20); emit Withdrawal(msg.sender, zrc20, receiver, amount, gasFee, IZRC20(zrc20).PROTOCOL_FLAT_FEE(), message); } // Withdraw ZETA to external chain - function withdraw(uint256 amount) external { + function withdraw(uint256 amount) external nonReentrant { _transferZETA(amount, FUNGIBLE_MODULE_ADDRESS); emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, ""); } // Withdraw ZETA and call smart contract on external chain - function withdrawAndCall(uint256 amount, bytes calldata message) external { + function withdrawAndCall(uint256 amount, bytes calldata message) external nonReentrant { _transferZETA(amount, FUNGIBLE_MODULE_ADDRESS); emit Withdrawal(msg.sender, address(0), abi.encodePacked(FUNGIBLE_MODULE_ADDRESS), amount, 0, 0, message); } // Call smart contract on external chain without asset transfer - function call(bytes memory receiver, bytes calldata message) external { + function call(bytes memory receiver, bytes calldata message) external nonReentrant { emit Call(msg.sender, receiver, message); } @@ -139,6 +140,6 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O if (target == FUNGIBLE_MODULE_ADDRESS || target == address(this)) revert InvalidTarget(); _transferZETA(amount, target); - zContract(target).onCrossChainCall(context, wzeta, amount, message); + zContract(target).onCrossChainCall(context, zetaToken, amount, message); } } diff --git a/contracts/prototypes/zevm/interfaces.sol b/contracts/prototypes/zevm/IGatewayZEVM.sol similarity index 97% rename from contracts/prototypes/zevm/interfaces.sol rename to contracts/prototypes/zevm/IGatewayZEVM.sol index fda7bcae..3c1a95f1 100644 --- a/contracts/prototypes/zevm/interfaces.sol +++ b/contracts/prototypes/zevm/IGatewayZEVM.sol @@ -46,6 +46,6 @@ interface IGatewayZEVMErrors { error GasFeeTransferFailed(); error CallerIsNotFungibleModule(); error InvalidTarget(); - error WZETATransferFailed(); + error ZetaTokenTransferFailed(); error FailedZetaSent(); } \ No newline at end of file diff --git a/contracts/prototypes/zevm/SenderZEVM.sol b/contracts/prototypes/zevm/SenderZEVM.sol index 711d1d97..8099a15d 100644 --- a/contracts/prototypes/zevm/SenderZEVM.sol +++ b/contracts/prototypes/zevm/SenderZEVM.sol @@ -2,7 +2,7 @@ pragma solidity 0.8.7; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./interfaces.sol"; +import "./IGatewayZEVM.sol"; import "../../zevm/interfaces/IZRC20.sol"; contract SenderZEVM { diff --git a/testFoundry/GatewayEVM.t.sol b/testFoundry/GatewayEVM.t.sol index 877ba316..b965a725 100644 --- a/testFoundry/GatewayEVM.t.sol +++ b/testFoundry/GatewayEVM.t.sol @@ -12,7 +12,8 @@ import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; -import "contracts/prototypes/evm/interfaces.sol"; +import "contracts/prototypes/evm/IGatewayEVM.sol"; +import "contracts/prototypes/evm/IReceiverEVM.sol"; import {Upgrades} from "openzeppelin-foundry-upgrades/LegacyUpgrades.sol"; contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiverEVMEvents { diff --git a/testFoundry/GatewayEVMUpgrade.t.sol b/testFoundry/GatewayEVMUpgrade.t.sol index fa3a1879..55c2a035 100644 --- a/testFoundry/GatewayEVMUpgrade.t.sol +++ b/testFoundry/GatewayEVMUpgrade.t.sol @@ -13,7 +13,8 @@ import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; -import "contracts/prototypes/evm/interfaces.sol"; +import "contracts/prototypes/evm/IGatewayEVM.sol"; +import "contracts/prototypes/evm/IReceiverEVM.sol"; import {Upgrades} from "openzeppelin-foundry-upgrades/LegacyUpgrades.sol"; contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiverEVMEvents { diff --git a/testFoundry/GatewayEVMZEVM.t.sol b/testFoundry/GatewayEVMZEVM.t.sol index 8e1044bd..ea2ccf2d 100644 --- a/testFoundry/GatewayEVMZEVM.t.sol +++ b/testFoundry/GatewayEVMZEVM.t.sol @@ -18,8 +18,9 @@ import "contracts/zevm/testing/SystemContractMock.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "contracts/prototypes/evm/interfaces.sol"; -import "contracts/prototypes/zevm/interfaces.sol"; +import "contracts/prototypes/evm/IGatewayEVM.sol"; +import "contracts/prototypes/evm/IReceiverEVM.sol"; +import "contracts/prototypes/zevm/IGatewayZEVM.sol"; import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; import {Upgrades} from "openzeppelin-foundry-upgrades/LegacyUpgrades.sol"; diff --git a/testFoundry/GatewayZEVM.t.sol b/testFoundry/GatewayZEVM.t.sol index f52b5194..95640dc0 100644 --- a/testFoundry/GatewayZEVM.t.sol +++ b/testFoundry/GatewayZEVM.t.sol @@ -9,7 +9,7 @@ import "contracts/zevm/ZRC20New.sol"; import "contracts/zevm/SystemContract.sol"; import "contracts/zevm/interfaces/IZRC20.sol"; import "contracts/prototypes/zevm/TestZContract.sol"; -import "contracts/prototypes/zevm/interfaces.sol"; +import "contracts/prototypes/zevm/IGatewayZEVM.sol"; import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; import {Upgrades} from "openzeppelin-foundry-upgrades/LegacyUpgrades.sol"; From 141bafe30880d3148d81f56e23176bb90d29cb6f Mon Sep 17 00:00:00 2001 From: skosito Date: Thu, 18 Jul 2024 16:49:15 +0200 Subject: [PATCH 82/86] generate --- .../erc20custodynew.sol/erc20custodynew.go | 2 +- .../evm/gatewayevm.sol/gatewayevm.go | 76 ++-- .../gatewayevmupgradetest.go | 70 ++-- .../igatewayevm.go | 10 +- .../igatewayevmerrors.go | 2 +- .../igatewayevmevents.go | 2 +- .../ireceiverevmevents.go | 2 +- .../zetaconnectornew.sol/zetaconnectornew.go | 32 +- .../zevm/gatewayzevm.sol/gatewayzevm.go | 46 +-- .../igatewayzevm.go | 2 +- .../igatewayzevmerrors.go | 4 +- .../igatewayzevmevents.go | 2 +- .../zevm/senderzevm.sol/senderzevm.go | 2 +- .../contracts/prototypes/evm/GatewayEVM.ts | 40 +- .../prototypes/evm/GatewayEVMUpgradeTest.ts | 38 +- .../evm/IGatewayEVM.sol/IGatewayEVM.ts | 165 ++++++++ .../evm/IGatewayEVM.sol/IGatewayEVMErrors.ts | 56 +++ .../evm/IGatewayEVM.sol/IGatewayEVMEvents.ts | 165 ++++++++ .../prototypes/evm/IGatewayEVM.sol/index.ts | 6 + .../IReceiverEVM.sol/IReceiverEVMEvents.ts | 162 ++++++++ .../prototypes/evm/IReceiverEVM.sol/index.ts | 4 + .../prototypes/evm/ZetaConnectorNew.ts | 22 +- .../contracts/prototypes/evm/index.ts | 6 +- .../contracts/prototypes/zevm/GatewayZEVM.ts | 28 +- .../zevm/IGatewayZEVM.sol/IGatewayZEVM.ts | 389 ++++++++++++++++++ .../IGatewayZEVM.sol/IGatewayZEVMErrors.ts | 56 +++ .../IGatewayZEVM.sol/IGatewayZEVMEvents.ts | 117 ++++++ .../prototypes/zevm/IGatewayZEVM.sol/index.ts | 6 + .../contracts/prototypes/zevm/index.ts | 4 +- .../evm/ERC20CustodyNew__factory.ts | 2 +- .../evm/GatewayEVMUpgradeTest__factory.ts | 8 +- .../prototypes/evm/GatewayEVM__factory.ts | 16 +- .../IGatewayEVMErrors__factory.ts | 61 +++ .../IGatewayEVMEvents__factory.ts | 144 +++++++ .../IGatewayEVM.sol/IGatewayEVM__factory.ts | 78 ++++ .../prototypes/evm/IGatewayEVM.sol/index.ts | 6 + .../IReceiverEVMEvents__factory.ts | 138 +++++++ .../prototypes/evm/IReceiverEVM.sol/index.ts | 4 + .../evm/ZetaConnectorNew__factory.ts | 14 +- .../contracts/prototypes/evm/index.ts | 3 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 14 +- .../IGatewayZEVMErrors__factory.ts | 71 ++++ .../IGatewayZEVMEvents__factory.ts | 100 +++++ .../IGatewayZEVM.sol/IGatewayZEVM__factory.ts | 218 ++++++++++ .../prototypes/zevm/IGatewayZEVM.sol/index.ts | 6 + .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- .../contracts/prototypes/zevm/index.ts | 2 +- typechain-types/index.ts | 28 +- 48 files changed, 2192 insertions(+), 239 deletions(-) rename pkg/contracts/prototypes/evm/{interfaces.sol => igatewayevm.sol}/igatewayevm.go (97%) rename pkg/contracts/prototypes/evm/{interfaces.sol => igatewayevm.sol}/igatewayevmerrors.go (99%) rename pkg/contracts/prototypes/evm/{interfaces.sol => igatewayevm.sol}/igatewayevmevents.go (99%) rename pkg/contracts/prototypes/evm/{interfaces.sol => ireceiverevm.sol}/ireceiverevmevents.go (99%) rename pkg/contracts/prototypes/zevm/{interfaces.sol => igatewayzevm.sol}/igatewayzevm.go (99%) rename pkg/contracts/prototypes/zevm/{interfaces.sol => igatewayzevm.sol}/igatewayzevmerrors.go (96%) rename pkg/contracts/prototypes/zevm/{interfaces.sol => igatewayzevm.sol}/igatewayzevmevents.go (99%) create mode 100644 typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM.ts create mode 100644 typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors.ts create mode 100644 typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents.ts create mode 100644 typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents.ts create mode 100644 typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/index.ts create mode 100644 typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM.ts create mode 100644 typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors.ts create mode 100644 typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents.ts create mode 100644 typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/index.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts diff --git a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go index 31454cbd..64ab0ba2 100644 --- a/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go +++ b/pkg/contracts/prototypes/evm/erc20custodynew.sol/erc20custodynew.go @@ -32,7 +32,7 @@ var ( // ERC20CustodyNewMetaData contains all meta data concerning the ERC20CustodyNew contract. var ERC20CustodyNewMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "0x60806040523480156200001157600080fd5b506040516200109038038062001090833981810160405281019062000037919062000106565b6001600081905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415620000a7576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b80600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550506200018b565b600081519050620001008162000171565b92915050565b6000602082840312156200011f576200011e6200016c565b5b60006200012f84828501620000ef565b91505092915050565b600062000145826200014c565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6200017c8162000138565b81146200018857600080fd5b50565b610ef5806200019b6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063116191b61461004657806321fc65f214610064578063d9caed1214610080575b600080fd5b61004e61009c565b60405161005b9190610a98565b60405180910390f35b61007e600480360381019061007991906107bc565b6100c2565b005b61009a60048036038101906100959190610769565b61024a565b005b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6100ca6102ef565b610117600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16848773ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16635131ab5986868686866040518663ffffffff1660e01b815260040161017a959493929190610a21565b600060405180830381600087803b15801561019457600080fd5b505af11580156101a8573d6000803e3d6000fd5b505050506040513d6000823e3d601f19601f820116820180604052508101906101d19190610871565b508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167f85b5be9cf454e05e0bddf49315178102227c312078eefa3c00294fb4d912ae4e85858560405161023393929190610b70565b60405180910390a36102436103c5565b5050505050565b6102526102ef565b61027d82828573ffffffffffffffffffffffffffffffffffffffff1661033f9092919063ffffffff16565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f9b1bfa7fa9ee420a16e124f794c35ac9f90472acc99140eb2f6447c714cad8eb836040516102da9190610b55565b60405180910390a36102ea6103c5565b505050565b60026000541415610335576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161032c90610b35565b60405180910390fd5b6002600081905550565b6103c08363a9059cbb60e01b848460405160240161035e929190610a6f565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff83818316178352505050506103cf565b505050565b6001600081905550565b6000610431826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166104969092919063ffffffff16565b905060008151111561049157808060200190518101906104519190610844565b610490576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161048790610b15565b60405180910390fd5b5b505050565b60606104a584846000856104ae565b90509392505050565b6060824710156104f3576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104ea90610ad5565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff16858760405161051c9190610a0a565b60006040518083038185875af1925050503d8060008114610559576040519150601f19603f3d011682016040523d82523d6000602084013e61055e565b606091505b509150915061056f8783838761057b565b92505050949350505050565b606083156105de576000835114156105d657610596856105f1565b6105d5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016105cc90610af5565b60405180910390fd5b5b8290506105e9565b6105e88383610614565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156106275781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161065b9190610ab3565b60405180910390fd5b600061067761067284610bc7565b610ba2565b90508281526020810184848401111561069357610692610d6a565b5b61069e848285610cc8565b509392505050565b6000813590506106b581610e7a565b92915050565b6000815190506106ca81610e91565b92915050565b60008083601f8401126106e6576106e5610d60565b5b8235905067ffffffffffffffff81111561070357610702610d5b565b5b60208301915083600182028301111561071f5761071e610d65565b5b9250929050565b600082601f83011261073b5761073a610d60565b5b815161074b848260208601610664565b91505092915050565b60008135905061076381610ea8565b92915050565b60008060006060848603121561078257610781610d74565b5b6000610790868287016106a6565b93505060206107a1868287016106a6565b92505060406107b286828701610754565b9150509250925092565b6000806000806000608086880312156107d8576107d7610d74565b5b60006107e6888289016106a6565b95505060206107f7888289016106a6565b945050604061080888828901610754565b935050606086013567ffffffffffffffff81111561082957610828610d6f565b5b610835888289016106d0565b92509250509295509295909350565b60006020828403121561085a57610859610d74565b5b6000610868848285016106bb565b91505092915050565b60006020828403121561088757610886610d74565b5b600082015167ffffffffffffffff8111156108a5576108a4610d6f565b5b6108b184828501610726565b91505092915050565b6108c381610c3b565b82525050565b60006108d58385610c0e565b93506108e2838584610cb9565b6108eb83610d79565b840190509392505050565b600061090182610bf8565b61090b8185610c1f565b935061091b818560208601610cc8565b80840191505092915050565b61093081610c83565b82525050565b600061094182610c03565b61094b8185610c2a565b935061095b818560208601610cc8565b61096481610d79565b840191505092915050565b600061097c602683610c2a565b915061098782610d8a565b604082019050919050565b600061099f601d83610c2a565b91506109aa82610dd9565b602082019050919050565b60006109c2602a83610c2a565b91506109cd82610e02565b604082019050919050565b60006109e5601f83610c2a565b91506109f082610e51565b602082019050919050565b610a0481610c79565b82525050565b6000610a1682846108f6565b915081905092915050565b6000608082019050610a3660008301886108ba565b610a4360208301876108ba565b610a5060408301866109fb565b8181036060830152610a638184866108c9565b90509695505050505050565b6000604082019050610a8460008301856108ba565b610a9160208301846109fb565b9392505050565b6000602082019050610aad6000830184610927565b92915050565b60006020820190508181036000830152610acd8184610936565b905092915050565b60006020820190508181036000830152610aee8161096f565b9050919050565b60006020820190508181036000830152610b0e81610992565b9050919050565b60006020820190508181036000830152610b2e816109b5565b9050919050565b60006020820190508181036000830152610b4e816109d8565b9050919050565b6000602082019050610b6a60008301846109fb565b92915050565b6000604082019050610b8560008301866109fb565b8181036020830152610b988184866108c9565b9050949350505050565b6000610bac610bbd565b9050610bb88282610cfb565b919050565b6000604051905090565b600067ffffffffffffffff821115610be257610be1610d2c565b5b610beb82610d79565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600081905092915050565b600082825260208201905092915050565b6000610c4682610c59565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000610c8e82610c95565b9050919050565b6000610ca082610ca7565b9050919050565b6000610cb282610c59565b9050919050565b82818337600083830152505050565b60005b83811015610ce6578082015181840152602081019050610ccb565b83811115610cf5576000848401525b50505050565b610d0482610d79565b810181811067ffffffffffffffff82111715610d2357610d22610d2c565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b610e8381610c3b565b8114610e8e57600080fd5b50565b610e9a81610c4d565b8114610ea557600080fd5b50565b610eb181610c79565b8114610ebc57600080fd5b5056fea26469706673582212209da1299d57511a448299616d5b9981cce3a960f4b22dcb0d38ff714263de7de564736f6c63430008070033", + Bin: "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", } // ERC20CustodyNewABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index cb5e4857..0ded7e7e 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -31,8 +31,8 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. @@ -326,12 +326,12 @@ func (_GatewayEVM *GatewayEVMCallerSession) TssAddress() (common.Address, error) return _GatewayEVM.Contract.TssAddress(&_GatewayEVM.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVM *GatewayEVMCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVM.contract.Call(opts, &out, "zeta") + err := _GatewayEVM.contract.Call(opts, &out, "zetaConnector") if err != nil { return *new(common.Address), err @@ -343,26 +343,26 @@ func (_GatewayEVM *GatewayEVMCaller) Zeta(opts *bind.CallOpts) (common.Address, } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVM *GatewayEVMSession) Zeta() (common.Address, error) { - return _GatewayEVM.Contract.Zeta(&_GatewayEVM.CallOpts) +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMSession) ZetaConnector() (common.Address, error) { + return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVM *GatewayEVMCallerSession) Zeta() (common.Address, error) { - return _GatewayEVM.Contract.Zeta(&_GatewayEVM.CallOpts) +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) ZetaConnector() (common.Address, error) { + return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVM *GatewayEVMCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVM *GatewayEVMCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVM.contract.Call(opts, &out, "zetaConnector") + err := _GatewayEVM.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -374,18 +374,18 @@ func (_GatewayEVM *GatewayEVMCaller) ZetaConnector(opts *bind.CallOpts) (common. } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVM *GatewayEVMSession) ZetaConnector() (common.Address, error) { - return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVM *GatewayEVMSession) ZetaToken() (common.Address, error) { + return _GatewayEVM.Contract.ZetaToken(&_GatewayEVM.CallOpts) } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVM *GatewayEVMCallerSession) ZetaConnector() (common.Address, error) { - return _GatewayEVM.Contract.ZetaConnector(&_GatewayEVM.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVM *GatewayEVMCallerSession) ZetaToken() (common.Address, error) { + return _GatewayEVM.Contract.ZetaToken(&_GatewayEVM.CallOpts) } // Call is a paid mutator transaction binding the contract method 0x1b8b921d. @@ -516,44 +516,44 @@ func (_GatewayEVM *GatewayEVMTransactorSession) Execute(destination common.Addre // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_GatewayEVM *GatewayEVMTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _GatewayEVM.contract.Transact(opts, "executeWithERC20", token, to, amount, data) } // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_GatewayEVM *GatewayEVMSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _GatewayEVM.Contract.ExecuteWithERC20(&_GatewayEVM.TransactOpts, token, to, amount, data) } // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_GatewayEVM *GatewayEVMTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _GatewayEVM.Contract.ExecuteWithERC20(&_GatewayEVM.TransactOpts, token, to, amount, data) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVM *GatewayEVMTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVM.contract.Transact(opts, "initialize", _tssAddress, _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVM *GatewayEVMSession) Initialize(_tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVM *GatewayEVMTransactorSession) Initialize(_tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVM.Contract.Initialize(&_GatewayEVM.TransactOpts, _tssAddress, _zetaToken) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. diff --git a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go index 1bcb2b99..02beccdc 100644 --- a/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go +++ b/pkg/contracts/prototypes/evm/gatewayevmupgradetest.sol/gatewayevmupgradetest.go @@ -31,8 +31,8 @@ var ( // GatewayEVMUpgradeTestMetaData contains all meta data concerning the GatewayEVMUpgradeTest contract. var GatewayEVMUpgradeTestMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedV2\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayEVMUpgradeTestABI is the input ABI used to generate the binding from. @@ -326,12 +326,12 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) TssAddress() ( return _GatewayEVMUpgradeTest.Contract.TssAddress(&_GatewayEVMUpgradeTest.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zeta") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaConnector") if err != nil { return *new(common.Address), err @@ -343,26 +343,26 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) Zeta(opts *bind.CallO } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Zeta() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.Zeta(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaConnector() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. // -// Solidity: function zeta() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) Zeta() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.Zeta(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zetaConnector() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaConnector() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaConnector(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaConnector") + err := _GatewayEVMUpgradeTest.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -374,18 +374,18 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCaller) ZetaConnector(opts *b } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaConnector() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) ZetaToken() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaToken(&_GatewayEVMUpgradeTest.CallOpts) } -// ZetaConnector is a free data retrieval call binding the contract method 0x57bec62f. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zetaConnector() view returns(address) -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaConnector() (common.Address, error) { - return _GatewayEVMUpgradeTest.Contract.ZetaConnector(&_GatewayEVMUpgradeTest.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestCallerSession) ZetaToken() (common.Address, error) { + return _GatewayEVMUpgradeTest.Contract.ZetaToken(&_GatewayEVMUpgradeTest.CallOpts) } // Call is a paid mutator transaction binding the contract method 0x1b8b921d. @@ -537,23 +537,23 @@ func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) ExecuteWit // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactor) Initialize(opts *bind.TransactOpts, _tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.contract.Transact(opts, "initialize", _tssAddress, _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestSession) Initialize(_tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0x485cc955. // -// Solidity: function initialize(address _tssAddress, address _zeta) returns() -func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address, _zeta common.Address) (*types.Transaction, error) { - return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zeta) +// Solidity: function initialize(address _tssAddress, address _zetaToken) returns() +func (_GatewayEVMUpgradeTest *GatewayEVMUpgradeTestTransactorSession) Initialize(_tssAddress common.Address, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayEVMUpgradeTest.Contract.Initialize(&_GatewayEVMUpgradeTest.TransactOpts, _tssAddress, _zetaToken) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevm.go similarity index 97% rename from pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go rename to pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevm.go index 6317820c..accd3193 100644 --- a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevm.go +++ b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevm.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayevm import ( "errors" @@ -31,7 +31,7 @@ var ( // IGatewayEVMMetaData contains all meta data concerning the IGatewayEVM contract. var IGatewayEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", } // IGatewayEVMABI is the input ABI used to generate the binding from. @@ -203,21 +203,21 @@ func (_IGatewayEVM *IGatewayEVMTransactorSession) Execute(destination common.Add // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_IGatewayEVM *IGatewayEVMTransactor) ExecuteWithERC20(opts *bind.TransactOpts, token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _IGatewayEVM.contract.Transact(opts, "executeWithERC20", token, to, amount, data) } // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_IGatewayEVM *IGatewayEVMSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _IGatewayEVM.Contract.ExecuteWithERC20(&_IGatewayEVM.TransactOpts, token, to, amount, data) } // ExecuteWithERC20 is a paid mutator transaction binding the contract method 0x5131ab59. // -// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns(bytes) +// Solidity: function executeWithERC20(address token, address to, uint256 amount, bytes data) returns() func (_IGatewayEVM *IGatewayEVMTransactorSession) ExecuteWithERC20(token common.Address, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { return _IGatewayEVM.Contract.ExecuteWithERC20(&_IGatewayEVM.TransactOpts, token, to, amount, data) } diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmerrors.go similarity index 99% rename from pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go rename to pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmerrors.go index 1c913e25..d4c84c67 100644 --- a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmerrors.go +++ b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmerrors.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayevm import ( "errors" diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmevents.go similarity index 99% rename from pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go rename to pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmevents.go index 2302001c..99a00bf3 100644 --- a/pkg/contracts/prototypes/evm/interfaces.sol/igatewayevmevents.go +++ b/pkg/contracts/prototypes/evm/igatewayevm.sol/igatewayevmevents.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayevm import ( "errors" diff --git a/pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go b/pkg/contracts/prototypes/evm/ireceiverevm.sol/ireceiverevmevents.go similarity index 99% rename from pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go rename to pkg/contracts/prototypes/evm/ireceiverevm.sol/ireceiverevmevents.go index cb37e582..7d00091d 100644 --- a/pkg/contracts/prototypes/evm/interfaces.sol/ireceiverevmevents.go +++ b/pkg/contracts/prototypes/evm/ireceiverevm.sol/ireceiverevmevents.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package ireceiverevm import ( "errors" diff --git a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go index 7b5fca00..b3224285 100644 --- a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go +++ b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go @@ -31,8 +31,8 @@ var ( // ZetaConnectorNewMetaData contains all meta data concerning the ZetaConnectorNew contract. var ZetaConnectorNewMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zeta\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zeta\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // ZetaConnectorNewABI is the input ABI used to generate the binding from. @@ -44,7 +44,7 @@ var ZetaConnectorNewABI = ZetaConnectorNewMetaData.ABI var ZetaConnectorNewBin = ZetaConnectorNewMetaData.Bin // DeployZetaConnectorNew deploys a new Ethereum contract, binding an instance of ZetaConnectorNew to it. -func DeployZetaConnectorNew(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zeta common.Address) (common.Address, *types.Transaction, *ZetaConnectorNew, error) { +func DeployZetaConnectorNew(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNew, error) { parsed, err := ZetaConnectorNewMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err @@ -53,7 +53,7 @@ func DeployZetaConnectorNew(auth *bind.TransactOpts, backend bind.ContractBacken return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNewBin), backend, _gateway, _zeta) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNewBin), backend, _gateway, _zetaToken) if err != nil { return common.Address{}, nil, nil, err } @@ -233,12 +233,12 @@ func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) Gateway() (common.Addres return _ZetaConnectorNew.Contract.Gateway(&_ZetaConnectorNew.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zeta() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCaller) Zeta(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ZetaConnectorNew.contract.Call(opts, &out, "zeta") + err := _ZetaConnectorNew.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -250,18 +250,18 @@ func (_ZetaConnectorNew *ZetaConnectorNewCaller) Zeta(opts *bind.CallOpts) (comm } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zeta() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewSession) Zeta() (common.Address, error) { - return _ZetaConnectorNew.Contract.Zeta(&_ZetaConnectorNew.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNew.Contract.ZetaToken(&_ZetaConnectorNew.CallOpts) } -// Zeta is a free data retrieval call binding the contract method 0xe8f9cb3a. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function zeta() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) Zeta() (common.Address, error) { - return _ZetaConnectorNew.Contract.Zeta(&_ZetaConnectorNew.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNew.Contract.ZetaToken(&_ZetaConnectorNew.CallOpts) } // Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 6e574512..09f8a4fe 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -38,8 +38,8 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_wzeta\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"wzeta\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZetaTokenTransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. @@ -302,12 +302,12 @@ func (_GatewayZEVM *GatewayZEVMCallerSession) ProxiableUUID() ([32]byte, error) return _GatewayZEVM.Contract.ProxiableUUID(&_GatewayZEVM.CallOpts) } -// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function wzeta() view returns(address) -func (_GatewayZEVM *GatewayZEVMCaller) Wzeta(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function zetaToken() view returns(address) +func (_GatewayZEVM *GatewayZEVMCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _GatewayZEVM.contract.Call(opts, &out, "wzeta") + err := _GatewayZEVM.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -319,18 +319,18 @@ func (_GatewayZEVM *GatewayZEVMCaller) Wzeta(opts *bind.CallOpts) (common.Addres } -// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function wzeta() view returns(address) -func (_GatewayZEVM *GatewayZEVMSession) Wzeta() (common.Address, error) { - return _GatewayZEVM.Contract.Wzeta(&_GatewayZEVM.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayZEVM *GatewayZEVMSession) ZetaToken() (common.Address, error) { + return _GatewayZEVM.Contract.ZetaToken(&_GatewayZEVM.CallOpts) } -// Wzeta is a free data retrieval call binding the contract method 0x00173d46. +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // -// Solidity: function wzeta() view returns(address) -func (_GatewayZEVM *GatewayZEVMCallerSession) Wzeta() (common.Address, error) { - return _GatewayZEVM.Contract.Wzeta(&_GatewayZEVM.CallOpts) +// Solidity: function zetaToken() view returns(address) +func (_GatewayZEVM *GatewayZEVMCallerSession) ZetaToken() (common.Address, error) { + return _GatewayZEVM.Contract.ZetaToken(&_GatewayZEVM.CallOpts) } // Call is a paid mutator transaction binding the contract method 0x0ac7c44c. @@ -440,23 +440,23 @@ func (_GatewayZEVM *GatewayZEVMTransactorSession) Execute(context ZContext, zrc2 // Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize(address _wzeta) returns() -func (_GatewayZEVM *GatewayZEVMTransactor) Initialize(opts *bind.TransactOpts, _wzeta common.Address) (*types.Transaction, error) { - return _GatewayZEVM.contract.Transact(opts, "initialize", _wzeta) +// Solidity: function initialize(address _zetaToken) returns() +func (_GatewayZEVM *GatewayZEVMTransactor) Initialize(opts *bind.TransactOpts, _zetaToken common.Address) (*types.Transaction, error) { + return _GatewayZEVM.contract.Transact(opts, "initialize", _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize(address _wzeta) returns() -func (_GatewayZEVM *GatewayZEVMSession) Initialize(_wzeta common.Address) (*types.Transaction, error) { - return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _wzeta) +// Solidity: function initialize(address _zetaToken) returns() +func (_GatewayZEVM *GatewayZEVMSession) Initialize(_zetaToken common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _zetaToken) } // Initialize is a paid mutator transaction binding the contract method 0xc4d66de8. // -// Solidity: function initialize(address _wzeta) returns() -func (_GatewayZEVM *GatewayZEVMTransactorSession) Initialize(_wzeta common.Address) (*types.Transaction, error) { - return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _wzeta) +// Solidity: function initialize(address _zetaToken) returns() +func (_GatewayZEVM *GatewayZEVMTransactorSession) Initialize(_zetaToken common.Address) (*types.Transaction, error) { + return _GatewayZEVM.Contract.Initialize(&_GatewayZEVM.TransactOpts, _zetaToken) } // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevm.go similarity index 99% rename from pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go rename to pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevm.go index 7d2b4bda..746cf4d9 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevm.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayzevm import ( "errors" diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go similarity index 96% rename from pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go rename to pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go index 1308aa3c..229c59f5 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmerrors.go +++ b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayzevm import ( "errors" @@ -31,7 +31,7 @@ var ( // IGatewayZEVMErrorsMetaData contains all meta data concerning the IGatewayZEVMErrors contract. var IGatewayZEVMErrorsMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WZETATransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"}]", + ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZetaTokenTransferFailed\",\"type\":\"error\"}]", } // IGatewayZEVMErrorsABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmevents.go similarity index 99% rename from pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go rename to pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmevents.go index 0b128fce..26208431 100644 --- a/pkg/contracts/prototypes/zevm/interfaces.sol/igatewayzevmevents.go +++ b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmevents.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package interfaces +package igatewayzevm import ( "errors" diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index dec285be..57cbb878 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts index 82a91b20..04dd59a3 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVM.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVM.ts @@ -48,8 +48,8 @@ export interface GatewayEVMInterface extends utils.Interface { "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; - "zeta()": FunctionFragment; "zetaConnector()": FunctionFragment; + "zetaToken()": FunctionFragment; }; getFunction( @@ -72,8 +72,8 @@ export interface GatewayEVMInterface extends utils.Interface { | "tssAddress" | "upgradeTo" | "upgradeToAndCall" - | "zeta" | "zetaConnector" + | "zetaToken" ): FunctionFragment; encodeFunctionData( @@ -156,11 +156,11 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; - encodeFunctionData(functionFragment: "zeta", values?: undefined): string; encodeFunctionData( functionFragment: "zetaConnector", values?: undefined ): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; @@ -210,11 +210,11 @@ export interface GatewayEVMInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; decodeFunctionResult( functionFragment: "zetaConnector", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; events: { "AdminChanged(address,address)": EventFragment; @@ -412,7 +412,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -452,9 +452,9 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise<[string]>; - zetaConnector(overrides?: CallOverrides): Promise<[string]>; + + zetaToken(overrides?: CallOverrides): Promise<[string]>; }; call( @@ -507,7 +507,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -547,10 +547,10 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; + callStatic: { call( receiver: PromiseOrValue, @@ -598,11 +598,11 @@ export interface GatewayEVM extends BaseContract { amount: PromiseOrValue, data: PromiseOrValue, overrides?: CallOverrides - ): Promise; + ): Promise; initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -640,9 +640,9 @@ export interface GatewayEVM extends BaseContract { overrides?: CallOverrides ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; filters: { @@ -783,7 +783,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -823,9 +823,9 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -879,7 +879,7 @@ export interface GatewayEVM extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -919,8 +919,8 @@ export interface GatewayEVM extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts index f38ef42e..1b50a64b 100644 --- a/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts +++ b/typechain-types/contracts/prototypes/evm/GatewayEVMUpgradeTest.ts @@ -48,8 +48,8 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { "tssAddress()": FunctionFragment; "upgradeTo(address)": FunctionFragment; "upgradeToAndCall(address,bytes)": FunctionFragment; - "zeta()": FunctionFragment; "zetaConnector()": FunctionFragment; + "zetaToken()": FunctionFragment; }; getFunction( @@ -72,8 +72,8 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { | "tssAddress" | "upgradeTo" | "upgradeToAndCall" - | "zeta" | "zetaConnector" + | "zetaToken" ): FunctionFragment; encodeFunctionData( @@ -156,11 +156,11 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", values: [PromiseOrValue, PromiseOrValue] ): string; - encodeFunctionData(functionFragment: "zeta", values?: undefined): string; encodeFunctionData( functionFragment: "zetaConnector", values?: undefined ): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; decodeFunctionResult(functionFragment: "custody", data: BytesLike): Result; @@ -210,11 +210,11 @@ export interface GatewayEVMUpgradeTestInterface extends utils.Interface { functionFragment: "upgradeToAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; decodeFunctionResult( functionFragment: "zetaConnector", data: BytesLike ): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; events: { "AdminChanged(address,address)": EventFragment; @@ -426,7 +426,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -466,9 +466,9 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise<[string]>; - zetaConnector(overrides?: CallOverrides): Promise<[string]>; + + zetaToken(overrides?: CallOverrides): Promise<[string]>; }; call( @@ -521,7 +521,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -561,10 +561,10 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; + callStatic: { call( receiver: PromiseOrValue, @@ -616,7 +616,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -654,9 +654,9 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: CallOverrides ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; filters: { @@ -808,7 +808,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -848,9 +848,9 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -904,7 +904,7 @@ export interface GatewayEVMUpgradeTest extends BaseContract { initialize( _tssAddress: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -944,8 +944,8 @@ export interface GatewayEVMUpgradeTest extends BaseContract { overrides?: PayableOverrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; - zetaConnector(overrides?: CallOverrides): Promise; + + zetaToken(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM.ts b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM.ts new file mode 100644 index 00000000..f6825a45 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM.ts @@ -0,0 +1,165 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PayableOverrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMInterface extends utils.Interface { + functions: { + "execute(address,bytes)": FunctionFragment; + "executeWithERC20(address,address,uint256,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: "execute" | "executeWithERC20" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "execute", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "executeWithERC20", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "executeWithERC20", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IGatewayEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + execute( + destination: PromiseOrValue, + data: PromiseOrValue, + overrides?: PayableOverrides & { from?: PromiseOrValue } + ): Promise; + + executeWithERC20( + token: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors.ts b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors.ts new file mode 100644 index 00000000..83722e4a --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface IGatewayEVMErrors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents.ts b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents.ts new file mode 100644 index 00000000..5346a379 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents.ts @@ -0,0 +1,165 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "Call(address,address,bytes)": EventFragment; + "Deposit(address,address,uint256,address,bytes)": EventFragment; + "Executed(address,uint256,bytes)": EventFragment; + "ExecutedWithERC20(address,address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Deposit"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Executed"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ExecutedWithERC20"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + payload: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface DepositEventObject { + sender: string; + receiver: string; + amount: BigNumber; + asset: string; + payload: string; +} +export type DepositEvent = TypedEvent< + [string, string, BigNumber, string, string], + DepositEventObject +>; + +export type DepositEventFilter = TypedEventFilter; + +export interface ExecutedEventObject { + destination: string; + value: BigNumber; + data: string; +} +export type ExecutedEvent = TypedEvent< + [string, BigNumber, string], + ExecutedEventObject +>; + +export type ExecutedEventFilter = TypedEventFilter; + +export interface ExecutedWithERC20EventObject { + token: string; + to: string; + amount: BigNumber; + data: string; +} +export type ExecutedWithERC20Event = TypedEvent< + [string, string, BigNumber, string], + ExecutedWithERC20EventObject +>; + +export type ExecutedWithERC20EventFilter = + TypedEventFilter; + +export interface IGatewayEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Call(address,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + payload?: null + ): CallEventFilter; + + "Deposit(address,address,uint256,address,bytes)"( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + Deposit( + sender?: PromiseOrValue | null, + receiver?: PromiseOrValue | null, + amount?: null, + asset?: null, + payload?: null + ): DepositEventFilter; + + "Executed(address,uint256,bytes)"( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + Executed( + destination?: PromiseOrValue | null, + value?: null, + data?: null + ): ExecutedEventFilter; + + "ExecutedWithERC20(address,address,uint256,bytes)"( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + ExecutedWithERC20( + token?: PromiseOrValue | null, + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): ExecutedWithERC20EventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/index.ts b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/index.ts new file mode 100644 index 00000000..caefde48 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IGatewayEVM.sol/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IGatewayEVM } from "./IGatewayEVM"; +export type { IGatewayEVMErrors } from "./IGatewayEVMErrors"; +export type { IGatewayEVMEvents } from "./IGatewayEVMEvents"; diff --git a/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents.ts b/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents.ts new file mode 100644 index 00000000..b29196dc --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents.ts @@ -0,0 +1,162 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IReceiverEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "ReceivedERC20(address,uint256,address,address)": EventFragment; + "ReceivedNoParams(address)": EventFragment; + "ReceivedNonPayable(address,string[],uint256[],bool)": EventFragment; + "ReceivedPayable(address,uint256,string,uint256,bool)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "ReceivedERC20"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNoParams"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedNonPayable"): EventFragment; + getEvent(nameOrSignatureOrTopic: "ReceivedPayable"): EventFragment; +} + +export interface ReceivedERC20EventObject { + sender: string; + amount: BigNumber; + token: string; + destination: string; +} +export type ReceivedERC20Event = TypedEvent< + [string, BigNumber, string, string], + ReceivedERC20EventObject +>; + +export type ReceivedERC20EventFilter = TypedEventFilter; + +export interface ReceivedNoParamsEventObject { + sender: string; +} +export type ReceivedNoParamsEvent = TypedEvent< + [string], + ReceivedNoParamsEventObject +>; + +export type ReceivedNoParamsEventFilter = + TypedEventFilter; + +export interface ReceivedNonPayableEventObject { + sender: string; + strs: string[]; + nums: BigNumber[]; + flag: boolean; +} +export type ReceivedNonPayableEvent = TypedEvent< + [string, string[], BigNumber[], boolean], + ReceivedNonPayableEventObject +>; + +export type ReceivedNonPayableEventFilter = + TypedEventFilter; + +export interface ReceivedPayableEventObject { + sender: string; + value: BigNumber; + str: string; + num: BigNumber; + flag: boolean; +} +export type ReceivedPayableEvent = TypedEvent< + [string, BigNumber, string, BigNumber, boolean], + ReceivedPayableEventObject +>; + +export type ReceivedPayableEventFilter = TypedEventFilter; + +export interface IReceiverEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IReceiverEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "ReceivedERC20(address,uint256,address,address)"( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + ReceivedERC20( + sender?: null, + amount?: null, + token?: null, + destination?: null + ): ReceivedERC20EventFilter; + + "ReceivedNoParams(address)"(sender?: null): ReceivedNoParamsEventFilter; + ReceivedNoParams(sender?: null): ReceivedNoParamsEventFilter; + + "ReceivedNonPayable(address,string[],uint256[],bool)"( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + ReceivedNonPayable( + sender?: null, + strs?: null, + nums?: null, + flag?: null + ): ReceivedNonPayableEventFilter; + + "ReceivedPayable(address,uint256,string,uint256,bool)"( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + ReceivedPayable( + sender?: null, + value?: null, + str?: null, + num?: null, + flag?: null + ): ReceivedPayableEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/index.ts b/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/index.ts new file mode 100644 index 00000000..6abc6179 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IReceiverEVM.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IReceiverEVMEvents } from "./IReceiverEVMEvents"; diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts index 812ea2e0..97b9e359 100644 --- a/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts @@ -32,11 +32,15 @@ export interface ZetaConnectorNewInterface extends utils.Interface { "gateway()": FunctionFragment; "withdraw(address,uint256)": FunctionFragment; "withdrawAndCall(address,uint256,bytes)": FunctionFragment; - "zeta()": FunctionFragment; + "zetaToken()": FunctionFragment; }; getFunction( - nameOrSignatureOrTopic: "gateway" | "withdraw" | "withdrawAndCall" | "zeta" + nameOrSignatureOrTopic: + | "gateway" + | "withdraw" + | "withdrawAndCall" + | "zetaToken" ): FunctionFragment; encodeFunctionData(functionFragment: "gateway", values?: undefined): string; @@ -52,7 +56,7 @@ export interface ZetaConnectorNewInterface extends utils.Interface { PromiseOrValue ] ): string; - encodeFunctionData(functionFragment: "zeta", values?: undefined): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; @@ -60,7 +64,7 @@ export interface ZetaConnectorNewInterface extends utils.Interface { functionFragment: "withdrawAndCall", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "zeta", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; events: { "Withdraw(address,uint256)": EventFragment; @@ -136,7 +140,7 @@ export interface ZetaConnectorNew extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise<[string]>; + zetaToken(overrides?: CallOverrides): Promise<[string]>; }; gateway(overrides?: CallOverrides): Promise; @@ -154,7 +158,7 @@ export interface ZetaConnectorNew extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; callStatic: { gateway(overrides?: CallOverrides): Promise; @@ -172,7 +176,7 @@ export interface ZetaConnectorNew extends BaseContract { overrides?: CallOverrides ): Promise; - zeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; filters: { @@ -213,7 +217,7 @@ export interface ZetaConnectorNew extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -232,6 +236,6 @@ export interface ZetaConnectorNew extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - zeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 48438670..9a11608e 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -1,8 +1,10 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as interfacesSol from "./interfaces.sol"; -export type { interfacesSol }; +import type * as iGatewayEvmSol from "./IGatewayEVM.sol"; +export type { iGatewayEvmSol }; +import type * as iReceiverEvmSol from "./IReceiverEVM.sol"; +export type { iReceiverEvmSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { GatewayEVM } from "./GatewayEVM"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; diff --git a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts index d24a0e4f..af765858 100644 --- a/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts +++ b/typechain-types/contracts/prototypes/zevm/GatewayZEVM.ts @@ -59,7 +59,7 @@ export interface GatewayZEVMInterface extends utils.Interface { "withdraw(uint256)": FunctionFragment; "withdrawAndCall(uint256,bytes)": FunctionFragment; "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; - "wzeta()": FunctionFragment; + "zetaToken()": FunctionFragment; }; getFunction( @@ -81,7 +81,7 @@ export interface GatewayZEVMInterface extends utils.Interface { | "withdraw(uint256)" | "withdrawAndCall(uint256,bytes)" | "withdrawAndCall(bytes,uint256,address,bytes)" - | "wzeta" + | "zetaToken" ): FunctionFragment; encodeFunctionData( @@ -179,7 +179,7 @@ export interface GatewayZEVMInterface extends utils.Interface { PromiseOrValue ] ): string; - encodeFunctionData(functionFragment: "wzeta", values?: undefined): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; decodeFunctionResult( functionFragment: "FUNGIBLE_MODULE_ADDRESS", @@ -231,7 +231,7 @@ export interface GatewayZEVMInterface extends utils.Interface { functionFragment: "withdrawAndCall(bytes,uint256,address,bytes)", data: BytesLike ): Result; - decodeFunctionResult(functionFragment: "wzeta", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; events: { "AdminChanged(address,address)": EventFragment; @@ -393,7 +393,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( - _wzeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -447,7 +447,7 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - wzeta(overrides?: CallOverrides): Promise<[string]>; + zetaToken(overrides?: CallOverrides): Promise<[string]>; }; FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; @@ -492,7 +492,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( - _wzeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -546,7 +546,7 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - wzeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; callStatic: { FUNGIBLE_MODULE_ADDRESS(overrides?: CallOverrides): Promise; @@ -591,7 +591,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( - _wzeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: CallOverrides ): Promise; @@ -643,7 +643,7 @@ export interface GatewayZEVM extends BaseContract { overrides?: CallOverrides ): Promise; - wzeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; filters: { @@ -756,7 +756,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( - _wzeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -810,7 +810,7 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - wzeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; populateTransaction: { @@ -858,7 +858,7 @@ export interface GatewayZEVM extends BaseContract { ): Promise; initialize( - _wzeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise; @@ -912,6 +912,6 @@ export interface GatewayZEVM extends BaseContract { overrides?: Overrides & { from?: PromiseOrValue } ): Promise; - wzeta(overrides?: CallOverrides): Promise; + zetaToken(overrides?: CallOverrides): Promise; }; } diff --git a/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM.ts b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM.ts new file mode 100644 index 00000000..12f1fa68 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM.ts @@ -0,0 +1,389 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { FunctionFragment, Result } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export type ZContextStruct = { + origin: PromiseOrValue; + sender: PromiseOrValue; + chainID: PromiseOrValue; +}; + +export type ZContextStructOutput = [string, string, BigNumber] & { + origin: string; + sender: string; + chainID: BigNumber; +}; + +export interface IGatewayZEVMInterface extends utils.Interface { + functions: { + "call(bytes,bytes)": FunctionFragment; + "deposit(address,uint256,address)": FunctionFragment; + "depositAndCall((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; + "execute((bytes,address,uint256),address,uint256,address,bytes)": FunctionFragment; + "withdraw(bytes,uint256,address)": FunctionFragment; + "withdrawAndCall(bytes,uint256,address,bytes)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "call" + | "deposit" + | "depositAndCall" + | "execute" + | "withdraw" + | "withdrawAndCall" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "call", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "deposit", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "depositAndCall", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "execute", + values: [ + ZContextStruct, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "call", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "depositAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + + events: {}; +} + +export interface IGatewayZEVM extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: {}; + + estimateGas: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + call( + receiver: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + deposit( + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + depositAndCall( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + execute( + context: ZContextStruct, + zrc20: PromiseOrValue, + amount: PromiseOrValue, + target: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + receiver: PromiseOrValue, + amount: PromiseOrValue, + zrc20: PromiseOrValue, + message: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors.ts b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors.ts new file mode 100644 index 00000000..74cfd7ba --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors.ts @@ -0,0 +1,56 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, Signer, utils } from "ethers"; + +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayZEVMErrorsInterface extends utils.Interface { + functions: {}; + + events: {}; +} + +export interface IGatewayZEVMErrors extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMErrorsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: {}; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents.ts b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents.ts new file mode 100644 index 00000000..829208d9 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents.ts @@ -0,0 +1,117 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { BaseContract, BigNumber, Signer, utils } from "ethers"; +import type { EventFragment } from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../../common"; + +export interface IGatewayZEVMEventsInterface extends utils.Interface { + functions: {}; + + events: { + "Call(address,bytes,bytes)": EventFragment; + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Call"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Withdrawal"): EventFragment; +} + +export interface CallEventObject { + sender: string; + receiver: string; + message: string; +} +export type CallEvent = TypedEvent<[string, string, string], CallEventObject>; + +export type CallEventFilter = TypedEventFilter; + +export interface WithdrawalEventObject { + from: string; + zrc20: string; + to: string; + value: BigNumber; + gasfee: BigNumber; + protocolFlatFee: BigNumber; + message: string; +} +export type WithdrawalEvent = TypedEvent< + [string, string, string, BigNumber, BigNumber, BigNumber, string], + WithdrawalEventObject +>; + +export type WithdrawalEventFilter = TypedEventFilter; + +export interface IGatewayZEVMEvents extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IGatewayZEVMEventsInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: {}; + + callStatic: {}; + + filters: { + "Call(address,bytes,bytes)"( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): CallEventFilter; + Call( + sender?: PromiseOrValue | null, + receiver?: null, + message?: null + ): CallEventFilter; + + "Withdrawal(address,address,bytes,uint256,uint256,uint256,bytes)"( + from?: PromiseOrValue | null, + zrc20?: null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + Withdrawal( + from?: PromiseOrValue | null, + zrc20?: null, + to?: null, + value?: null, + gasfee?: null, + protocolFlatFee?: null, + message?: null + ): WithdrawalEventFilter; + }; + + estimateGas: {}; + + populateTransaction: {}; +} diff --git a/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts new file mode 100644 index 00000000..736bdfc6 --- /dev/null +++ b/typechain-types/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export type { IGatewayZEVM } from "./IGatewayZEVM"; +export type { IGatewayZEVMErrors } from "./IGatewayZEVMErrors"; +export type { IGatewayZEVMEvents } from "./IGatewayZEVMEvents"; diff --git a/typechain-types/contracts/prototypes/zevm/index.ts b/typechain-types/contracts/prototypes/zevm/index.ts index 1a6e2455..edbfa71c 100644 --- a/typechain-types/contracts/prototypes/zevm/index.ts +++ b/typechain-types/contracts/prototypes/zevm/index.ts @@ -1,8 +1,8 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -import type * as interfacesSol from "./interfaces.sol"; -export type { interfacesSol }; +import type * as iGatewayZevmSol from "./IGatewayZEVM.sol"; +export type { iGatewayZevmSol }; export type { GatewayZEVM } from "./GatewayZEVM"; export type { SenderZEVM } from "./SenderZEVM"; export type { TestZContract } from "./TestZContract"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts index ecd43202..3f8b6da3 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ERC20CustodyNew__factory.ts @@ -149,7 +149,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ERC20CustodyNewConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts index 8b8846f6..ba1bb546 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory.ts @@ -450,7 +450,7 @@ const _abi = [ }, { internalType: "address", - name: "_zeta", + name: "_zetaToken", type: "address", }, ], @@ -577,7 +577,7 @@ const _abi = [ }, { inputs: [], - name: "zeta", + name: "zetaConnector", outputs: [ { internalType: "address", @@ -590,7 +590,7 @@ const _abi = [ }, { inputs: [], - name: "zetaConnector", + name: "zetaToken", outputs: [ { internalType: "address", @@ -604,7 +604,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMUpgradeTestConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index e039fd9b..43dfec3f 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -406,13 +406,7 @@ const _abi = [ }, ], name: "executeWithERC20", - outputs: [ - { - internalType: "bytes", - name: "", - type: "bytes", - }, - ], + outputs: [], stateMutability: "nonpayable", type: "function", }, @@ -425,7 +419,7 @@ const _abi = [ }, { internalType: "address", - name: "_zeta", + name: "_zetaToken", type: "address", }, ], @@ -552,7 +546,7 @@ const _abi = [ }, { inputs: [], - name: "zeta", + name: "zetaConnector", outputs: [ { internalType: "address", @@ -565,7 +559,7 @@ const _abi = [ }, { inputs: [], - name: "zetaConnector", + name: "zetaToken", outputs: [ { internalType: "address", @@ -579,7 +573,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors__factory.ts new file mode 100644 index 00000000..f7e393b3 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors__factory.ts @@ -0,0 +1,61 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVMErrors, + IGatewayEVMErrorsInterface, +} from "../../../../../contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors"; + +const _abi = [ + { + inputs: [], + name: "ApprovalFailed", + type: "error", + }, + { + inputs: [], + name: "CustodyInitialized", + type: "error", + }, + { + inputs: [], + name: "DepositFailed", + type: "error", + }, + { + inputs: [], + name: "ExecutionFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientERC20Amount", + type: "error", + }, + { + inputs: [], + name: "InsufficientETHAmount", + type: "error", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, +] as const; + +export class IGatewayEVMErrors__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMErrorsInterface { + return new utils.Interface(_abi) as IGatewayEVMErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVMErrors { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVMErrors; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory.ts new file mode 100644 index 00000000..be4da675 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory.ts @@ -0,0 +1,144 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVMEvents, + IGatewayEVMEventsInterface, +} from "../../../../../contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "receiver", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "asset", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "payload", + type: "bytes", + }, + ], + name: "Deposit", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "destination", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "Executed", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "ExecutedWithERC20", + type: "event", + }, +] as const; + +export class IGatewayEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMEventsInterface { + return new utils.Interface(_abi) as IGatewayEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM__factory.ts new file mode 100644 index 00000000..30a73d41 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM__factory.ts @@ -0,0 +1,78 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayEVM, + IGatewayEVMInterface, +} from "../../../../../contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "destination", + type: "address", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "execute", + outputs: [ + { + internalType: "bytes", + name: "", + type: "bytes", + }, + ], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "token", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "executeWithERC20", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGatewayEVM__factory { + static readonly abi = _abi; + static createInterface(): IGatewayEVMInterface { + return new utils.Interface(_abi) as IGatewayEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayEVM { + return new Contract(address, _abi, signerOrProvider) as IGatewayEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/index.ts b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/index.ts new file mode 100644 index 00000000..4092d594 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IGatewayEVM.sol/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IGatewayEVM__factory } from "./IGatewayEVM__factory"; +export { IGatewayEVMErrors__factory } from "./IGatewayEVMErrors__factory"; +export { IGatewayEVMEvents__factory } from "./IGatewayEVMEvents__factory"; diff --git a/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory.ts new file mode 100644 index 00000000..f92fb1eb --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory.ts @@ -0,0 +1,138 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IReceiverEVMEvents, + IReceiverEVMEventsInterface, +} from "../../../../../contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "address", + name: "token", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "destination", + type: "address", + }, + ], + name: "ReceivedERC20", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + ], + name: "ReceivedNoParams", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "string[]", + name: "strs", + type: "string[]", + }, + { + indexed: false, + internalType: "uint256[]", + name: "nums", + type: "uint256[]", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedNonPayable", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "string", + name: "str", + type: "string", + }, + { + indexed: false, + internalType: "uint256", + name: "num", + type: "uint256", + }, + { + indexed: false, + internalType: "bool", + name: "flag", + type: "bool", + }, + ], + name: "ReceivedPayable", + type: "event", + }, +] as const; + +export class IReceiverEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IReceiverEVMEventsInterface { + return new utils.Interface(_abi) as IReceiverEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IReceiverEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IReceiverEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/index.ts b/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/index.ts new file mode 100644 index 00000000..49a704f0 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IReceiverEVM.sol/index.ts @@ -0,0 +1,4 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IReceiverEVMEvents__factory } from "./IReceiverEVMEvents__factory"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts index eea00da8..b14f7c62 100644 --- a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNew__factory.ts @@ -19,7 +19,7 @@ const _abi = [ }, { internalType: "address", - name: "_zeta", + name: "_zetaToken", type: "address", }, ], @@ -131,7 +131,7 @@ const _abi = [ }, { inputs: [], - name: "zeta", + name: "zetaToken", outputs: [ { internalType: "contract IERC20", @@ -145,7 +145,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type ZetaConnectorNewConstructorParams = | [signer?: Signer] @@ -166,21 +166,21 @@ export class ZetaConnectorNew__factory extends ContractFactory { override deploy( _gateway: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): Promise { return super.deploy( _gateway, - _zeta, + _zetaToken, overrides || {} ) as Promise; } override getDeployTransaction( _gateway: PromiseOrValue, - _zeta: PromiseOrValue, + _zetaToken: PromiseOrValue, overrides?: Overrides & { from?: PromiseOrValue } ): TransactionRequest { - return super.getDeployTransaction(_gateway, _zeta, overrides || {}); + return super.getDeployTransaction(_gateway, _zetaToken, overrides || {}); } override attach(address: string): ZetaConnectorNew { return super.attach(address) as ZetaConnectorNew; diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index ffd0d34a..31c7fa9c 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -1,7 +1,8 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as interfacesSol from "./interfaces.sol"; +export * as iGatewayEvmSol from "./IGatewayEVM.sol"; +export * as iReceiverEvmSol from "./IReceiverEVM.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index b3212e3f..bb6b2758 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -42,22 +42,22 @@ const _abi = [ }, { inputs: [], - name: "WZETATransferFailed", + name: "WithdrawalFailed", type: "error", }, { inputs: [], - name: "WithdrawalFailed", + name: "ZRC20BurnFailed", type: "error", }, { inputs: [], - name: "ZRC20BurnFailed", + name: "ZRC20TransferFailed", type: "error", }, { inputs: [], - name: "ZRC20TransferFailed", + name: "ZetaTokenTransferFailed", type: "error", }, { @@ -414,7 +414,7 @@ const _abi = [ inputs: [ { internalType: "address", - name: "_wzeta", + name: "_zetaToken", type: "address", }, ], @@ -584,7 +584,7 @@ const _abi = [ }, { inputs: [], - name: "wzeta", + name: "zetaToken", outputs: [ { internalType: "address", @@ -598,7 +598,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts new file mode 100644 index 00000000..410b76b8 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts @@ -0,0 +1,71 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVMErrors, + IGatewayZEVMErrorsInterface, +} from "../../../../../contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors"; + +const _abi = [ + { + inputs: [], + name: "CallerIsNotFungibleModule", + type: "error", + }, + { + inputs: [], + name: "FailedZetaSent", + type: "error", + }, + { + inputs: [], + name: "GasFeeTransferFailed", + type: "error", + }, + { + inputs: [], + name: "InsufficientZRC20Amount", + type: "error", + }, + { + inputs: [], + name: "InvalidTarget", + type: "error", + }, + { + inputs: [], + name: "WithdrawalFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20BurnFailed", + type: "error", + }, + { + inputs: [], + name: "ZRC20TransferFailed", + type: "error", + }, + { + inputs: [], + name: "ZetaTokenTransferFailed", + type: "error", + }, +] as const; + +export class IGatewayZEVMErrors__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMErrorsInterface { + return new utils.Interface(_abi) as IGatewayZEVMErrorsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVMErrors { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVMErrors; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents__factory.ts new file mode 100644 index 00000000..64cc4932 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents__factory.ts @@ -0,0 +1,100 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVMEvents, + IGatewayZEVMEventsInterface, +} from "../../../../../contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "sender", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Call", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: false, + internalType: "address", + name: "zrc20", + type: "address", + }, + { + indexed: false, + internalType: "bytes", + name: "to", + type: "bytes", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "gasfee", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "protocolFlatFee", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "Withdrawal", + type: "event", + }, +] as const; + +export class IGatewayZEVMEvents__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMEventsInterface { + return new utils.Interface(_abi) as IGatewayZEVMEventsInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVMEvents { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVMEvents; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM__factory.ts new file mode 100644 index 00000000..d9cd417d --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM__factory.ts @@ -0,0 +1,218 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IGatewayZEVM, + IGatewayZEVMInterface, +} from "../../../../../contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM"; + +const _abi = [ + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "call", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + ], + name: "deposit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "depositAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + components: [ + { + internalType: "bytes", + name: "origin", + type: "bytes", + }, + { + internalType: "address", + name: "sender", + type: "address", + }, + { + internalType: "uint256", + name: "chainID", + type: "uint256", + }, + ], + internalType: "struct zContext", + name: "context", + type: "tuple", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "target", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "execute", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "receiver", + type: "bytes", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "address", + name: "zrc20", + type: "address", + }, + { + internalType: "bytes", + name: "message", + type: "bytes", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IGatewayZEVM__factory { + static readonly abi = _abi; + static createInterface(): IGatewayZEVMInterface { + return new utils.Interface(_abi) as IGatewayZEVMInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IGatewayZEVM { + return new Contract(address, _abi, signerOrProvider) as IGatewayZEVM; + } +} diff --git a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts new file mode 100644 index 00000000..0b6212ee --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/index.ts @@ -0,0 +1,6 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +export { IGatewayZEVM__factory } from "./IGatewayZEVM__factory"; +export { IGatewayZEVMErrors__factory } from "./IGatewayZEVMErrors__factory"; +export { IGatewayZEVMEvents__factory } from "./IGatewayZEVMEvents__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index 577b6ab6..c05c5587 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/index.ts b/typechain-types/factories/contracts/prototypes/zevm/index.ts index 051c4305..d8c3ab1e 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/index.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/index.ts @@ -1,7 +1,7 @@ /* Autogenerated file. Do not edit manually. */ /* tslint:disable */ /* eslint-disable */ -export * as interfacesSol from "./interfaces.sol"; +export * as iGatewayZevmSol from "./IGatewayZEVM.sol"; export { GatewayZEVM__factory } from "./GatewayZEVM__factory"; export { SenderZEVM__factory } from "./SenderZEVM__factory"; export { TestZContract__factory } from "./TestZContract__factory"; diff --git a/typechain-types/index.ts b/typechain-types/index.ts index d37c2b01..7416cf12 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -162,14 +162,14 @@ export type { GatewayEVM } from "./contracts/prototypes/evm/GatewayEVM"; export { GatewayEVM__factory } from "./factories/contracts/prototypes/evm/GatewayEVM__factory"; export type { GatewayEVMUpgradeTest } from "./contracts/prototypes/evm/GatewayEVMUpgradeTest"; export { GatewayEVMUpgradeTest__factory } from "./factories/contracts/prototypes/evm/GatewayEVMUpgradeTest__factory"; -export type { IGatewayEVM } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVM"; -export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVM__factory"; -export type { IGatewayEVMErrors } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors"; -export { IGatewayEVMErrors__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMErrors__factory"; -export type { IGatewayEVMEvents } from "./contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents"; -export { IGatewayEVMEvents__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IGatewayEVMEvents__factory"; -export type { IReceiverEVMEvents } from "./contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents"; -export { IReceiverEVMEvents__factory } from "./factories/contracts/prototypes/evm/interfaces.sol/IReceiverEVMEvents__factory"; +export type { IGatewayEVM } from "./contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM"; +export { IGatewayEVM__factory } from "./factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVM__factory"; +export type { IGatewayEVMErrors } from "./contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors"; +export { IGatewayEVMErrors__factory } from "./factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMErrors__factory"; +export type { IGatewayEVMEvents } from "./contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents"; +export { IGatewayEVMEvents__factory } from "./factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory"; +export type { IReceiverEVMEvents } from "./contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents"; +export { IReceiverEVMEvents__factory } from "./factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory"; export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; @@ -178,12 +178,12 @@ export type { ZetaConnectorNew } from "./contracts/prototypes/evm/ZetaConnectorN export { ZetaConnectorNew__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNew__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; -export type { IGatewayZEVM } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM"; -export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVM__factory"; -export type { IGatewayZEVMErrors } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors"; -export { IGatewayZEVMErrors__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMErrors__factory"; -export type { IGatewayZEVMEvents } from "./contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents"; -export { IGatewayZEVMEvents__factory } from "./factories/contracts/prototypes/zevm/interfaces.sol/IGatewayZEVMEvents__factory"; +export type { IGatewayZEVM } from "./contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM"; +export { IGatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM__factory"; +export type { IGatewayZEVMErrors } from "./contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors"; +export { IGatewayZEVMErrors__factory } from "./factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory"; +export type { IGatewayZEVMEvents } from "./contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents"; +export { IGatewayZEVMEvents__factory } from "./factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMEvents__factory"; export type { SenderZEVM } from "./contracts/prototypes/zevm/SenderZEVM"; export { SenderZEVM__factory } from "./factories/contracts/prototypes/zevm/SenderZEVM__factory"; export type { TestZContract } from "./contracts/prototypes/zevm/TestZContract"; From a68698ecf2463a7e98fa5d028d52e4d8c496f8a6 Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 19 Jul 2024 02:04:14 +0200 Subject: [PATCH 83/86] eth and non eth version of connector --- contracts/prototypes/evm/GatewayEVM.sol | 32 +++++++++--- contracts/prototypes/evm/IZetaNonEthNew.sol | 13 +++++ contracts/prototypes/evm/ZetaConnectorNew.sol | 51 ------------------- .../prototypes/evm/ZetaConnectorNewBase.sol | 33 ++++++++++++ .../prototypes/evm/ZetaConnectorNewEth.sol | 37 ++++++++++++++ .../prototypes/evm/ZetaConnectorNewNonEth.sol | 35 +++++++++++++ testFoundry/GatewayEVM.t.sol | 14 ++--- testFoundry/GatewayEVMUpgrade.t.sol | 6 +-- testFoundry/GatewayEVMZEVM.t.sol | 6 +-- 9 files changed, 155 insertions(+), 72 deletions(-) create mode 100644 contracts/prototypes/evm/IZetaNonEthNew.sol delete mode 100644 contracts/prototypes/evm/ZetaConnectorNew.sol create mode 100644 contracts/prototypes/evm/ZetaConnectorNewBase.sol create mode 100644 contracts/prototypes/evm/ZetaConnectorNewEth.sol create mode 100644 contracts/prototypes/evm/ZetaConnectorNewNonEth.sol diff --git a/contracts/prototypes/evm/GatewayEVM.sol b/contracts/prototypes/evm/GatewayEVM.sol index 68d2e49b..7d87fe71 100644 --- a/contracts/prototypes/evm/GatewayEVM.sol +++ b/contracts/prototypes/evm/GatewayEVM.sol @@ -7,6 +7,7 @@ import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "./IGatewayEVM.sol"; +import "./ZetaConnectorNewBase.sol"; /** * @title GatewayEVM @@ -89,7 +90,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate // Transfer any remaining tokens back to the custody/connector contract uint256 remainingBalance = IERC20(token).balanceOf(address(this)); if (remainingBalance > 0) { - IERC20(token).safeTransfer(getAssetHandler(token), remainingBalance); + transferToAssetHandler(token, amount); } emit ExecutedWithERC20(token, to, amount, data); @@ -109,7 +110,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function deposit(address receiver, uint256 amount, address asset) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).safeTransferFrom(msg.sender, getAssetHandler(asset), amount); + transferFromToAssetHandler(msg.sender, asset, amount); emit Deposit(msg.sender, receiver, amount, asset, ""); } @@ -128,7 +129,7 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate function depositAndCall(address receiver, uint256 amount, address asset, bytes calldata payload) external { if (amount == 0) revert InsufficientERC20Amount(); - IERC20(asset).safeTransferFrom(msg.sender, getAssetHandler(asset), amount); + transferFromToAssetHandler(msg.sender, asset, amount); emit Deposit(msg.sender, receiver, amount, asset, payload); } @@ -156,12 +157,27 @@ contract GatewayEVM is Initializable, OwnableUpgradeable, UUPSUpgradeable, IGate return IERC20(token).approve(to, 0); } - function getAssetHandler(address token) private returns (address) { - address assetHandler = address(custody); - if (token == zetaToken) { - assetHandler = address(zetaConnector); + function transferFromToAssetHandler(address from, address token, uint256 amount) private { + if (token == zetaToken) { // transfer to connector + // transfer amount to gateway + IERC20(token).safeTransferFrom(from, address(this), amount); + // approve connector to handle tokens depending on connector version (eg. lock or burn) + IERC20(token).approve(zetaConnector, amount); + // send tokens to connector + ZetaConnectorNewBase(zetaConnector).receiveTokens(amount); + } else { // transfer to custody + IERC20(token).safeTransferFrom(from, custody, amount); } + } - return assetHandler; + function transferToAssetHandler(address token, uint256 amount) private { + if (token == zetaToken) { // transfer to connector + // approve connector to handle tokens depending on connector version (eg. lock or burn) + IERC20(token).approve(zetaConnector, amount); + // send tokens to connector + ZetaConnectorNewBase(zetaConnector).receiveTokens(amount); + } else { // transfer to custody + IERC20(token).safeTransfer(custody, amount); + } } } diff --git a/contracts/prototypes/evm/IZetaNonEthNew.sol b/contracts/prototypes/evm/IZetaNonEthNew.sol new file mode 100644 index 00000000..5f0b1dd8 --- /dev/null +++ b/contracts/prototypes/evm/IZetaNonEthNew.sol @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +/** + * @dev IZetaNonEthNew is a mintable / burnable version of IERC20 + */ +interface IZetaNonEthNew is IERC20 { + function burnFrom(address account, uint256 amount) external; + + function mint(address mintee, uint256 value, bytes32 internalSendHash) external; +} \ No newline at end of file diff --git a/contracts/prototypes/evm/ZetaConnectorNew.sol b/contracts/prototypes/evm/ZetaConnectorNew.sol deleted file mode 100644 index b9e38d9e..00000000 --- a/contracts/prototypes/evm/ZetaConnectorNew.sol +++ /dev/null @@ -1,51 +0,0 @@ -// SPDX-License-Identifier: MIT -pragma solidity 0.8.7; - -import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; -import "./IGatewayEVM.sol"; -import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; - -contract ZetaConnectorNew is ReentrancyGuard{ - using SafeERC20 for IERC20; - error ZeroAddress(); - - IGatewayEVM public immutable gateway; - IERC20 public immutable zetaToken; - - event Withdraw(address indexed to, uint256 amount); - event WithdrawAndCall(address indexed to, uint256 amount, bytes data); - - constructor(address _gateway, address _zetaToken) { - if (_gateway == address(0) || _zetaToken == address(0)) { - revert ZeroAddress(); - } - gateway = IGatewayEVM(_gateway); - zetaToken = IERC20(_zetaToken); - } - - // Withdraw is called by TSS address, it directly transfers zetaToken to the destination address without contract call - // TODO: Finalize access control - // https://github.com/zeta-chain/protocol-contracts/issues/204 - function withdraw(address to, uint256 amount) external nonReentrant { - // TODO: mint? - zetaToken.safeTransfer(to, amount); - - emit Withdraw(to, amount); - } - - // WithdrawAndCall is called by TSS address, it transfers zetaToken and call a contract - // For this, it passes through the Gateway contract, it transfers zetaToken to the Gateway contract and then calls the contract - // TODO: Finalize access control - // https://github.com/zeta-chain/protocol-contracts/issues/204 - function withdrawAndCall(address to, uint256 amount, bytes calldata data) public nonReentrant { - // TODO: mint? - // Transfer zetaToken to the Gateway contract - zetaToken.safeTransfer(address(gateway), amount); - - // Forward the call to the Gateway contract - gateway.executeWithERC20(address(zetaToken), to, amount, data); - - emit WithdrawAndCall(to, amount, data); - } -} \ No newline at end of file diff --git a/contracts/prototypes/evm/ZetaConnectorNewBase.sol b/contracts/prototypes/evm/ZetaConnectorNewBase.sol new file mode 100644 index 00000000..6ae2ce06 --- /dev/null +++ b/contracts/prototypes/evm/ZetaConnectorNewBase.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "./IGatewayEVM.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; + +abstract contract ZetaConnectorNewBase is ReentrancyGuard { + using SafeERC20 for IERC20; + + error ZeroAddress(); + + IGatewayEVM public immutable gateway; + address public immutable zetaToken; + + event Withdraw(address indexed to, uint256 amount); + event WithdrawAndCall(address indexed to, uint256 amount, bytes data); + + constructor(address _gateway, address _zetaToken) { + if (_gateway == address(0) || _zetaToken == address(0)) { + revert ZeroAddress(); + } + gateway = IGatewayEVM(_gateway); + zetaToken = _zetaToken; + } + + function withdraw(address to, uint256 amount, bytes32 internalSendHash) external virtual; + + function withdrawAndCall(address to, uint256 amount, bytes calldata data, bytes32 internalSendHash) external virtual; + + function receiveTokens(uint256 amount) external virtual; +} \ No newline at end of file diff --git a/contracts/prototypes/evm/ZetaConnectorNewEth.sol b/contracts/prototypes/evm/ZetaConnectorNewEth.sol new file mode 100644 index 00000000..c4f0ef65 --- /dev/null +++ b/contracts/prototypes/evm/ZetaConnectorNewEth.sol @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "./ZetaConnectorNewBase.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; + +contract ZetaConnectorNewEth is ZetaConnectorNewBase { + using SafeERC20 for IERC20; + + constructor(address _gateway, address _zetaToken) + ZetaConnectorNewBase(_gateway, _zetaToken) + {} + + // Withdraw is called by TSS address, it directly transfers zetaToken to the destination address without contract call + function withdraw(address to, uint256 amount, bytes32 internalSendHash) external override nonReentrant { + IERC20(zetaToken).safeTransfer(to, amount); + emit Withdraw(to, amount); + } + + // WithdrawAndCall is called by TSS address, it transfers zetaToken to the gateway and calls a contract + function withdrawAndCall(address to, uint256 amount, bytes calldata data, bytes32 internalSendHash) external override nonReentrant { + // Transfer zetaToken to the Gateway contract + IERC20(zetaToken).safeTransfer(address(gateway), amount); + + // Forward the call to the Gateway contract + gateway.executeWithERC20(address(zetaToken), to, amount, data); + + emit WithdrawAndCall(to, amount, data); + } + + // Function to handle token transfer + function receiveTokens(uint256 amount) external override nonReentrant { + // Transfer tokens from the sender to this contract + IERC20(zetaToken).safeTransferFrom(msg.sender, address(this), amount); + } +} diff --git a/contracts/prototypes/evm/ZetaConnectorNewNonEth.sol b/contracts/prototypes/evm/ZetaConnectorNewNonEth.sol new file mode 100644 index 00000000..50d6a98e --- /dev/null +++ b/contracts/prototypes/evm/ZetaConnectorNewNonEth.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.7; + +import "./ZetaConnectorNewBase.sol"; +import "./IZetaNonEthNew.sol"; +import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol"; + +contract ZetaConnectorNewNonEth is ZetaConnectorNewBase { + constructor(address _gateway, address _zetaToken) + ZetaConnectorNewBase(_gateway, _zetaToken) + {} + + // Withdraw is called by TSS address, it mints zetaToken to the destination address + function withdraw(address to, uint256 amount, bytes32 internalSendHash) external override nonReentrant { + IZetaNonEthNew(zetaToken).mint(to, amount, internalSendHash); + emit Withdraw(to, amount); + } + + // WithdrawAndCall is called by TSS address, it mints zetaToken and calls a contract + function withdrawAndCall(address to, uint256 amount, bytes calldata data, bytes32 internalSendHash) external override nonReentrant { + // Mint zetaToken to the Gateway contract + IZetaNonEthNew(zetaToken).mint(address(gateway), amount, internalSendHash); + + // Forward the call to the Gateway contract + gateway.executeWithERC20(address(zetaToken), to, amount, data); + + emit WithdrawAndCall(to, amount, data); + } + + // Function to handle token transfer and burn them + function receiveTokens(uint256 amount) external override { + // Burn the tokens + IZetaNonEthNew(zetaToken).burnFrom(msg.sender, amount); + } +} diff --git a/testFoundry/GatewayEVM.t.sol b/testFoundry/GatewayEVM.t.sol index b965a725..2ac683e7 100644 --- a/testFoundry/GatewayEVM.t.sol +++ b/testFoundry/GatewayEVM.t.sol @@ -7,7 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -23,7 +23,7 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; - ZetaConnectorNew zetaConnector; + ZetaConnectorNewNonEth zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -47,7 +47,7 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); @@ -139,8 +139,8 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver vm.expectEmit(true, true, true, true, address(receiver)); emit ReceivedNoParams(address(gateway)); - vm.expectEmit(true, true, true, true, address(custody)); - emit WithdrawAndCall(address(token), address(receiver), amount, data); + // vm.expectEmit(true, true, true, true, address(custody)); + // emit WithdrawAndCall(address(token), address(receiver), amount, data); custody.withdrawAndCall(address(token), address(receiver), amount, data); // Verify that the tokens were not transferred to the destination address @@ -181,7 +181,7 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR GatewayEVM gateway; ERC20CustodyNew custody; - ZetaConnectorNew zetaConnector; + ZetaConnectorNewNonEth zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -203,7 +203,7 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); gateway.setCustody(address(custody)); gateway.setConnector(address(zetaConnector)); diff --git a/testFoundry/GatewayEVMUpgrade.t.sol b/testFoundry/GatewayEVMUpgrade.t.sol index 55c2a035..6960c90c 100644 --- a/testFoundry/GatewayEVMUpgrade.t.sol +++ b/testFoundry/GatewayEVMUpgrade.t.sol @@ -8,7 +8,7 @@ import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/GatewayEVMUpgradeTest.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -25,7 +25,7 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; - ZetaConnectorNew zetaConnector; + ZetaConnectorNewNonEth zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -47,7 +47,7 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNew(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); diff --git a/testFoundry/GatewayEVMZEVM.t.sol b/testFoundry/GatewayEVMZEVM.t.sol index ea2ccf2d..a3d94c93 100644 --- a/testFoundry/GatewayEVMZEVM.t.sol +++ b/testFoundry/GatewayEVMZEVM.t.sol @@ -7,7 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNew.sol"; +import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; @@ -31,7 +31,7 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate address proxyEVM; GatewayEVM gatewayEVM; ERC20CustodyNew custody; - ZetaConnectorNew zetaConnector; + ZetaConnectorNewNonEth zetaConnector; TestERC20 token; TestERC20 zeta; ReceiverEVM receiverEVM; @@ -63,7 +63,7 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate )); gatewayEVM = GatewayEVM(proxyEVM); custody = new ERC20CustodyNew(address(gatewayEVM)); - zetaConnector = new ZetaConnectorNew(address(gatewayEVM), address(zeta)); + zetaConnector = new ZetaConnectorNewNonEth(address(gatewayEVM), address(zeta)); gatewayEVM.setCustody(address(custody)); gatewayEVM.setConnector(address(zetaConnector)); From 61d2c9190a7156fa9cf30cd35e3d0274ff1499de Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 19 Jul 2024 02:11:54 +0200 Subject: [PATCH 84/86] generate --- .../evm/gatewayevm.sol/gatewayevm.go | 2 +- .../evm/izetanonethnew.sol/izetanonethnew.go | 687 ++++++++++++++++++ .../zetaconnectornew.sol/zetaconnectornew.go | 598 --------------- .../zetaconnectornewbase.go | 597 +++++++++++++++ .../zetaconnectorneweth.go | 619 ++++++++++++++++ .../zetaconnectornewnoneth.go | 619 ++++++++++++++++ .../prototypes/evm/IZetaNonEthNew.ts | 425 +++++++++++ .../prototypes/evm/ZetaConnectorNewBase.ts | 291 ++++++++ .../prototypes/evm/ZetaConnectorNewEth.ts | 291 ++++++++ .../prototypes/evm/ZetaConnectorNewNonEth.ts | 291 ++++++++ .../contracts/prototypes/evm/index.ts | 5 +- .../prototypes/evm/GatewayEVM__factory.ts | 2 +- .../prototypes/evm/IZetaNonEthNew__factory.ts | 250 +++++++ .../evm/ZetaConnectorNewBase__factory.ts | 169 +++++ .../evm/ZetaConnectorNewEth__factory.ts | 226 ++++++ .../evm/ZetaConnectorNewNonEth__factory.ts | 230 ++++++ .../contracts/prototypes/evm/index.ts | 5 +- typechain-types/hardhat.d.ts | 35 +- typechain-types/index.ts | 10 +- 19 files changed, 4744 insertions(+), 608 deletions(-) create mode 100644 pkg/contracts/prototypes/evm/izetanonethnew.sol/izetanonethnew.go delete mode 100644 pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go create mode 100644 pkg/contracts/prototypes/evm/zetaconnectornewbase.sol/zetaconnectornewbase.go create mode 100644 pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go create mode 100644 pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go create mode 100644 typechain-types/contracts/prototypes/evm/IZetaNonEthNew.ts create mode 100644 typechain-types/contracts/prototypes/evm/ZetaConnectorNewBase.ts create mode 100644 typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts create mode 100644 typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/IZetaNonEthNew__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory.ts diff --git a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go index 0ded7e7e..e7a70e1c 100644 --- a/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go +++ b/pkg/contracts/prototypes/evm/gatewayevm.sol/gatewayevm.go @@ -32,7 +32,7 @@ var ( // GatewayEVMMetaData contains all meta data concerning the GatewayEVM contract. var GatewayEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CustodyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientERC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"Deposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"Executed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ExecutedWithERC20\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custody\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"destination\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"executeWithERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_tssAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaConnector\",\"type\":\"address\"}],\"name\":\"setConnector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_custody\",\"type\":\"address\"}],\"name\":\"setCustody\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tssAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaConnector\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // GatewayEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/evm/izetanonethnew.sol/izetanonethnew.go b/pkg/contracts/prototypes/evm/izetanonethnew.sol/izetanonethnew.go new file mode 100644 index 00000000..01229f86 --- /dev/null +++ b/pkg/contracts/prototypes/evm/izetanonethnew.sol/izetanonethnew.go @@ -0,0 +1,687 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package izetanonethnew + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// IZetaNonEthNewMetaData contains all meta data concerning the IZetaNonEthNew contract. +var IZetaNonEthNewMetaData = &bind.MetaData{ + ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"mintee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", +} + +// IZetaNonEthNewABI is the input ABI used to generate the binding from. +// Deprecated: Use IZetaNonEthNewMetaData.ABI instead. +var IZetaNonEthNewABI = IZetaNonEthNewMetaData.ABI + +// IZetaNonEthNew is an auto generated Go binding around an Ethereum contract. +type IZetaNonEthNew struct { + IZetaNonEthNewCaller // Read-only binding to the contract + IZetaNonEthNewTransactor // Write-only binding to the contract + IZetaNonEthNewFilterer // Log filterer for contract events +} + +// IZetaNonEthNewCaller is an auto generated read-only Go binding around an Ethereum contract. +type IZetaNonEthNewCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZetaNonEthNewTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IZetaNonEthNewTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZetaNonEthNewFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IZetaNonEthNewFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IZetaNonEthNewSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IZetaNonEthNewSession struct { + Contract *IZetaNonEthNew // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IZetaNonEthNewCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IZetaNonEthNewCallerSession struct { + Contract *IZetaNonEthNewCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IZetaNonEthNewTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IZetaNonEthNewTransactorSession struct { + Contract *IZetaNonEthNewTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IZetaNonEthNewRaw is an auto generated low-level Go binding around an Ethereum contract. +type IZetaNonEthNewRaw struct { + Contract *IZetaNonEthNew // Generic contract binding to access the raw methods on +} + +// IZetaNonEthNewCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IZetaNonEthNewCallerRaw struct { + Contract *IZetaNonEthNewCaller // Generic read-only contract binding to access the raw methods on +} + +// IZetaNonEthNewTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IZetaNonEthNewTransactorRaw struct { + Contract *IZetaNonEthNewTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIZetaNonEthNew creates a new instance of IZetaNonEthNew, bound to a specific deployed contract. +func NewIZetaNonEthNew(address common.Address, backend bind.ContractBackend) (*IZetaNonEthNew, error) { + contract, err := bindIZetaNonEthNew(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IZetaNonEthNew{IZetaNonEthNewCaller: IZetaNonEthNewCaller{contract: contract}, IZetaNonEthNewTransactor: IZetaNonEthNewTransactor{contract: contract}, IZetaNonEthNewFilterer: IZetaNonEthNewFilterer{contract: contract}}, nil +} + +// NewIZetaNonEthNewCaller creates a new read-only instance of IZetaNonEthNew, bound to a specific deployed contract. +func NewIZetaNonEthNewCaller(address common.Address, caller bind.ContractCaller) (*IZetaNonEthNewCaller, error) { + contract, err := bindIZetaNonEthNew(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IZetaNonEthNewCaller{contract: contract}, nil +} + +// NewIZetaNonEthNewTransactor creates a new write-only instance of IZetaNonEthNew, bound to a specific deployed contract. +func NewIZetaNonEthNewTransactor(address common.Address, transactor bind.ContractTransactor) (*IZetaNonEthNewTransactor, error) { + contract, err := bindIZetaNonEthNew(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IZetaNonEthNewTransactor{contract: contract}, nil +} + +// NewIZetaNonEthNewFilterer creates a new log filterer instance of IZetaNonEthNew, bound to a specific deployed contract. +func NewIZetaNonEthNewFilterer(address common.Address, filterer bind.ContractFilterer) (*IZetaNonEthNewFilterer, error) { + contract, err := bindIZetaNonEthNew(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IZetaNonEthNewFilterer{contract: contract}, nil +} + +// bindIZetaNonEthNew binds a generic wrapper to an already deployed contract. +func bindIZetaNonEthNew(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := IZetaNonEthNewMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IZetaNonEthNew *IZetaNonEthNewRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IZetaNonEthNew.Contract.IZetaNonEthNewCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IZetaNonEthNew *IZetaNonEthNewRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.IZetaNonEthNewTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IZetaNonEthNew *IZetaNonEthNewRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.IZetaNonEthNewTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IZetaNonEthNew *IZetaNonEthNewCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _IZetaNonEthNew.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IZetaNonEthNew *IZetaNonEthNewTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IZetaNonEthNew *IZetaNonEthNewTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _IZetaNonEthNew.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 + +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IZetaNonEthNew.Contract.Allowance(&_IZetaNonEthNew.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IZetaNonEthNew.Contract.Allowance(&_IZetaNonEthNew.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _IZetaNonEthNew.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 + +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IZetaNonEthNew.Contract.BalanceOf(&_IZetaNonEthNew.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IZetaNonEthNew.Contract.BalanceOf(&_IZetaNonEthNew.CallOpts, account) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _IZetaNonEthNew.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 + +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewSession) TotalSupply() (*big.Int, error) { + return _IZetaNonEthNew.Contract.TotalSupply(&_IZetaNonEthNew.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_IZetaNonEthNew *IZetaNonEthNewCallerSession) TotalSupply() (*big.Int, error) { + return _IZetaNonEthNew.Contract.TotalSupply(&_IZetaNonEthNew.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.contract.Transact(opts, "approve", spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Approve(&_IZetaNonEthNew.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Approve(&_IZetaNonEthNew.TransactOpts, spender, amount) +} + +// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. +// +// Solidity: function burnFrom(address account, uint256 amount) returns() +func (_IZetaNonEthNew *IZetaNonEthNewTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.contract.Transact(opts, "burnFrom", account, amount) +} + +// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. +// +// Solidity: function burnFrom(address account, uint256 amount) returns() +func (_IZetaNonEthNew *IZetaNonEthNewSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.BurnFrom(&_IZetaNonEthNew.TransactOpts, account, amount) +} + +// BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. +// +// Solidity: function burnFrom(address account, uint256 amount) returns() +func (_IZetaNonEthNew *IZetaNonEthNewTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.BurnFrom(&_IZetaNonEthNew.TransactOpts, account, amount) +} + +// Mint is a paid mutator transaction binding the contract method 0x1e458bee. +// +// Solidity: function mint(address mintee, uint256 value, bytes32 internalSendHash) returns() +func (_IZetaNonEthNew *IZetaNonEthNewTransactor) Mint(opts *bind.TransactOpts, mintee common.Address, value *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _IZetaNonEthNew.contract.Transact(opts, "mint", mintee, value, internalSendHash) +} + +// Mint is a paid mutator transaction binding the contract method 0x1e458bee. +// +// Solidity: function mint(address mintee, uint256 value, bytes32 internalSendHash) returns() +func (_IZetaNonEthNew *IZetaNonEthNewSession) Mint(mintee common.Address, value *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Mint(&_IZetaNonEthNew.TransactOpts, mintee, value, internalSendHash) +} + +// Mint is a paid mutator transaction binding the contract method 0x1e458bee. +// +// Solidity: function mint(address mintee, uint256 value, bytes32 internalSendHash) returns() +func (_IZetaNonEthNew *IZetaNonEthNewTransactorSession) Mint(mintee common.Address, value *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Mint(&_IZetaNonEthNew.TransactOpts, mintee, value, internalSendHash) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Transfer(&_IZetaNonEthNew.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.Transfer(&_IZetaNonEthNew.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.TransferFrom(&_IZetaNonEthNew.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_IZetaNonEthNew *IZetaNonEthNewTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _IZetaNonEthNew.Contract.TransferFrom(&_IZetaNonEthNew.TransactOpts, from, to, amount) +} + +// IZetaNonEthNewApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IZetaNonEthNew contract. +type IZetaNonEthNewApprovalIterator struct { + Event *IZetaNonEthNewApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IZetaNonEthNewApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IZetaNonEthNewApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IZetaNonEthNewApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IZetaNonEthNewApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IZetaNonEthNewApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IZetaNonEthNewApproval represents a Approval event raised by the IZetaNonEthNew contract. +type IZetaNonEthNewApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IZetaNonEthNewApprovalIterator, 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 := _IZetaNonEthNew.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &IZetaNonEthNewApprovalIterator{contract: _IZetaNonEthNew.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IZetaNonEthNewApproval, 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 := _IZetaNonEthNew.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: + // New log arrived, parse the event and forward to the user + event := new(IZetaNonEthNewApproval) + if err := _IZetaNonEthNew.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 +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) ParseApproval(log types.Log) (*IZetaNonEthNewApproval, error) { + event := new(IZetaNonEthNewApproval) + if err := _IZetaNonEthNew.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// IZetaNonEthNewTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IZetaNonEthNew contract. +type IZetaNonEthNewTransferIterator struct { + Event *IZetaNonEthNewTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IZetaNonEthNewTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IZetaNonEthNewTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IZetaNonEthNewTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IZetaNonEthNewTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IZetaNonEthNewTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IZetaNonEthNewTransfer represents a Transfer event raised by the IZetaNonEthNew contract. +type IZetaNonEthNewTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IZetaNonEthNewTransferIterator, 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 := _IZetaNonEthNew.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &IZetaNonEthNewTransferIterator{contract: _IZetaNonEthNew.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IZetaNonEthNewTransfer, 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 := _IZetaNonEthNew.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: + // New log arrived, parse the event and forward to the user + event := new(IZetaNonEthNewTransfer) + if err := _IZetaNonEthNew.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 +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IZetaNonEthNew *IZetaNonEthNewFilterer) ParseTransfer(log types.Log) (*IZetaNonEthNewTransfer, error) { + event := new(IZetaNonEthNewTransfer) + if err := _IZetaNonEthNew.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go b/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go deleted file mode 100644 index b3224285..00000000 --- a/pkg/contracts/prototypes/evm/zetaconnectornew.sol/zetaconnectornew.go +++ /dev/null @@ -1,598 +0,0 @@ -// Code generated - DO NOT EDIT. -// This file is a generated binding and any manual changes will be lost. - -package zetaconnectornew - -import ( - "errors" - "math/big" - "strings" - - ethereum "github.com/ethereum/go-ethereum" - "github.com/ethereum/go-ethereum/accounts/abi" - "github.com/ethereum/go-ethereum/accounts/abi/bind" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/event" -) - -// Reference imports to suppress errors if they are not otherwise used. -var ( - _ = errors.New - _ = big.NewInt - _ = strings.NewReader - _ = ethereum.NotFound - _ = bind.Bind - _ = common.Big1 - _ = types.BloomLookup - _ = event.NewSubscription - _ = abi.ConvertType -) - -// ZetaConnectorNewMetaData contains all meta data concerning the ZetaConnectorNew contract. -var ZetaConnectorNewMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", -} - -// ZetaConnectorNewABI is the input ABI used to generate the binding from. -// Deprecated: Use ZetaConnectorNewMetaData.ABI instead. -var ZetaConnectorNewABI = ZetaConnectorNewMetaData.ABI - -// ZetaConnectorNewBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ZetaConnectorNewMetaData.Bin instead. -var ZetaConnectorNewBin = ZetaConnectorNewMetaData.Bin - -// DeployZetaConnectorNew deploys a new Ethereum contract, binding an instance of ZetaConnectorNew to it. -func DeployZetaConnectorNew(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNew, error) { - parsed, err := ZetaConnectorNewMetaData.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(ZetaConnectorNewBin), backend, _gateway, _zetaToken) - if err != nil { - return common.Address{}, nil, nil, err - } - return address, tx, &ZetaConnectorNew{ZetaConnectorNewCaller: ZetaConnectorNewCaller{contract: contract}, ZetaConnectorNewTransactor: ZetaConnectorNewTransactor{contract: contract}, ZetaConnectorNewFilterer: ZetaConnectorNewFilterer{contract: contract}}, nil -} - -// ZetaConnectorNew is an auto generated Go binding around an Ethereum contract. -type ZetaConnectorNew struct { - ZetaConnectorNewCaller // Read-only binding to the contract - ZetaConnectorNewTransactor // Write-only binding to the contract - ZetaConnectorNewFilterer // Log filterer for contract events -} - -// ZetaConnectorNewCaller is an auto generated read-only Go binding around an Ethereum contract. -type ZetaConnectorNewCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ZetaConnectorNewTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ZetaConnectorNewTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ZetaConnectorNewFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ZetaConnectorNewFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls -} - -// ZetaConnectorNewSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type ZetaConnectorNewSession struct { - Contract *ZetaConnectorNew // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ZetaConnectorNewCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type ZetaConnectorNewCallerSession struct { - Contract *ZetaConnectorNewCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} - -// ZetaConnectorNewTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type ZetaConnectorNewTransactorSession struct { - Contract *ZetaConnectorNewTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session -} - -// ZetaConnectorNewRaw is an auto generated low-level Go binding around an Ethereum contract. -type ZetaConnectorNewRaw struct { - Contract *ZetaConnectorNew // Generic contract binding to access the raw methods on -} - -// ZetaConnectorNewCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ZetaConnectorNewCallerRaw struct { - Contract *ZetaConnectorNewCaller // Generic read-only contract binding to access the raw methods on -} - -// ZetaConnectorNewTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ZetaConnectorNewTransactorRaw struct { - Contract *ZetaConnectorNewTransactor // Generic write-only contract binding to access the raw methods on -} - -// NewZetaConnectorNew creates a new instance of ZetaConnectorNew, bound to a specific deployed contract. -func NewZetaConnectorNew(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNew, error) { - contract, err := bindZetaConnectorNew(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &ZetaConnectorNew{ZetaConnectorNewCaller: ZetaConnectorNewCaller{contract: contract}, ZetaConnectorNewTransactor: ZetaConnectorNewTransactor{contract: contract}, ZetaConnectorNewFilterer: ZetaConnectorNewFilterer{contract: contract}}, nil -} - -// NewZetaConnectorNewCaller creates a new read-only instance of ZetaConnectorNew, bound to a specific deployed contract. -func NewZetaConnectorNewCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewCaller, error) { - contract, err := bindZetaConnectorNew(address, caller, nil, nil) - if err != nil { - return nil, err - } - return &ZetaConnectorNewCaller{contract: contract}, nil -} - -// NewZetaConnectorNewTransactor creates a new write-only instance of ZetaConnectorNew, bound to a specific deployed contract. -func NewZetaConnectorNewTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewTransactor, error) { - contract, err := bindZetaConnectorNew(address, nil, transactor, nil) - if err != nil { - return nil, err - } - return &ZetaConnectorNewTransactor{contract: contract}, nil -} - -// NewZetaConnectorNewFilterer creates a new log filterer instance of ZetaConnectorNew, bound to a specific deployed contract. -func NewZetaConnectorNewFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewFilterer, error) { - contract, err := bindZetaConnectorNew(address, nil, nil, filterer) - if err != nil { - return nil, err - } - return &ZetaConnectorNewFilterer{contract: contract}, nil -} - -// bindZetaConnectorNew binds a generic wrapper to an already deployed contract. -func bindZetaConnectorNew(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ZetaConnectorNewMetaData.GetAbi() - if err != nil { - return nil, err - } - return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ZetaConnectorNew *ZetaConnectorNewRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNew.Contract.ZetaConnectorNewCaller.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ZetaConnectorNew *ZetaConnectorNewRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.ZetaConnectorNewTransactor.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNew *ZetaConnectorNewRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.ZetaConnectorNewTransactor.contract.Transact(opts, method, params...) -} - -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_ZetaConnectorNew *ZetaConnectorNewCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNew.Contract.contract.Call(opts, result, method, params...) -} - -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_ZetaConnectorNew *ZetaConnectorNewTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.contract.Transfer(opts) -} - -// Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNew *ZetaConnectorNewTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.contract.Transact(opts, method, params...) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ZetaConnectorNew.contract.Call(opts, &out, "gateway") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewSession) Gateway() (common.Address, error) { - return _ZetaConnectorNew.Contract.Gateway(&_ZetaConnectorNew.CallOpts) -} - -// Gateway is a free data retrieval call binding the contract method 0x116191b6. -// -// Solidity: function gateway() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) Gateway() (common.Address, error) { - return _ZetaConnectorNew.Contract.Gateway(&_ZetaConnectorNew.CallOpts) -} - -// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. -// -// Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { - var out []interface{} - err := _ZetaConnectorNew.contract.Call(opts, &out, "zetaToken") - - if err != nil { - return *new(common.Address), err - } - - out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) - - return out0, err - -} - -// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. -// -// Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNew.Contract.ZetaToken(&_ZetaConnectorNew.CallOpts) -} - -// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. -// -// Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNew *ZetaConnectorNewCallerSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNew.Contract.ZetaToken(&_ZetaConnectorNew.CallOpts) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. -// -// Solidity: function withdraw(address to, uint256 amount) returns() -func (_ZetaConnectorNew *ZetaConnectorNewTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNew.contract.Transact(opts, "withdraw", to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. -// -// Solidity: function withdraw(address to, uint256 amount) returns() -func (_ZetaConnectorNew *ZetaConnectorNewSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.Withdraw(&_ZetaConnectorNew.TransactOpts, to, amount) -} - -// Withdraw is a paid mutator transaction binding the contract method 0xf3fef3a3. -// -// Solidity: function withdraw(address to, uint256 amount) returns() -func (_ZetaConnectorNew *ZetaConnectorNewTransactorSession) Withdraw(to common.Address, amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.Withdraw(&_ZetaConnectorNew.TransactOpts, to, amount) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. -// -// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ZetaConnectorNew *ZetaConnectorNewTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ZetaConnectorNew.contract.Transact(opts, "withdrawAndCall", to, amount, data) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. -// -// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ZetaConnectorNew *ZetaConnectorNewSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.WithdrawAndCall(&_ZetaConnectorNew.TransactOpts, to, amount, data) -} - -// WithdrawAndCall is a paid mutator transaction binding the contract method 0x02a04c0d. -// -// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data) returns() -func (_ZetaConnectorNew *ZetaConnectorNewTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { - return _ZetaConnectorNew.Contract.WithdrawAndCall(&_ZetaConnectorNew.TransactOpts, to, amount, data) -} - -// ZetaConnectorNewWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNew contract. -type ZetaConnectorNewWithdrawIterator struct { - Event *ZetaConnectorNewWithdraw // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewWithdrawIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ZetaConnectorNewWithdraw) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ZetaConnectorNewWithdraw) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewWithdrawIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ZetaConnectorNewWithdrawIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ZetaConnectorNewWithdraw represents a Withdraw event raised by the ZetaConnectorNew contract. -type ZetaConnectorNewWithdraw struct { - To common.Address - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. -// -// Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewWithdrawIterator, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ZetaConnectorNew.contract.FilterLogs(opts, "Withdraw", toRule) - if err != nil { - return nil, err - } - return &ZetaConnectorNewWithdrawIterator{contract: _ZetaConnectorNew.contract, event: "Withdraw", logs: logs, sub: sub}, nil -} - -// WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. -// -// Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewWithdraw, to []common.Address) (event.Subscription, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ZetaConnectorNew.contract.WatchLogs(opts, "Withdraw", toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewWithdraw) - if err := _ZetaConnectorNew.contract.UnpackLog(event, "Withdraw", 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 -} - -// ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. -// -// Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewWithdraw, error) { - event := new(ZetaConnectorNewWithdraw) - if err := _ZetaConnectorNew.contract.UnpackLog(event, "Withdraw", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} - -// ZetaConnectorNewWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNew contract. -type ZetaConnectorNewWithdrawAndCallIterator struct { - Event *ZetaConnectorNewWithdrawAndCall // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data - - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} - -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewWithdrawAndCallIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false - } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(ZetaConnectorNewWithdrawAndCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - default: - return false - } - } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(ZetaConnectorNewWithdrawAndCall) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } -} - -// Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewWithdrawAndCallIterator) Error() error { - return it.fail -} - -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *ZetaConnectorNewWithdrawAndCallIterator) Close() error { - it.sub.Unsubscribe() - return nil -} - -// ZetaConnectorNewWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNew contract. -type ZetaConnectorNewWithdrawAndCall struct { - To common.Address - Amount *big.Int - Data []byte - Raw types.Log // Blockchain specific contextual infos -} - -// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. -// -// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewWithdrawAndCallIterator, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ZetaConnectorNew.contract.FilterLogs(opts, "WithdrawAndCall", toRule) - if err != nil { - return nil, err - } - return &ZetaConnectorNewWithdrawAndCallIterator{contract: _ZetaConnectorNew.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil -} - -// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. -// -// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewWithdrawAndCall, to []common.Address) (event.Subscription, error) { - - var toRule []interface{} - for _, toItem := range to { - toRule = append(toRule, toItem) - } - - logs, sub, err := _ZetaConnectorNew.contract.WatchLogs(opts, "WithdrawAndCall", toRule) - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewWithdrawAndCall) - if err := _ZetaConnectorNew.contract.UnpackLog(event, "WithdrawAndCall", 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 -} - -// ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. -// -// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNew *ZetaConnectorNewFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewWithdrawAndCall, error) { - event := new(ZetaConnectorNewWithdrawAndCall) - if err := _ZetaConnectorNew.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { - return nil, err - } - event.Raw = log - return event, nil -} diff --git a/pkg/contracts/prototypes/evm/zetaconnectornewbase.sol/zetaconnectornewbase.go b/pkg/contracts/prototypes/evm/zetaconnectornewbase.sol/zetaconnectornewbase.go new file mode 100644 index 00000000..e9fea6d6 --- /dev/null +++ b/pkg/contracts/prototypes/evm/zetaconnectornewbase.sol/zetaconnectornewbase.go @@ -0,0 +1,597 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zetaconnectornewbase + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZetaConnectorNewBaseMetaData contains all meta data concerning the ZetaConnectorNewBase contract. +var ZetaConnectorNewBaseMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"receiveTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", +} + +// ZetaConnectorNewBaseABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNewBaseMetaData.ABI instead. +var ZetaConnectorNewBaseABI = ZetaConnectorNewBaseMetaData.ABI + +// ZetaConnectorNewBase is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNewBase struct { + ZetaConnectorNewBaseCaller // Read-only binding to the contract + ZetaConnectorNewBaseTransactor // Write-only binding to the contract + ZetaConnectorNewBaseFilterer // Log filterer for contract events +} + +// ZetaConnectorNewBaseCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNewBaseCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewBaseTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNewBaseTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNewBaseFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewBaseSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZetaConnectorNewBaseSession struct { + Contract *ZetaConnectorNewBase // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZetaConnectorNewBaseCallerSession struct { + Contract *ZetaConnectorNewBaseCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZetaConnectorNewBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZetaConnectorNewBaseTransactorSession struct { + Contract *ZetaConnectorNewBaseTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewBaseRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNewBaseRaw struct { + Contract *ZetaConnectorNewBase // Generic contract binding to access the raw methods on +} + +// ZetaConnectorNewBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNewBaseCallerRaw struct { + Contract *ZetaConnectorNewBaseCaller // Generic read-only contract binding to access the raw methods on +} + +// ZetaConnectorNewBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNewBaseTransactorRaw struct { + Contract *ZetaConnectorNewBaseTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZetaConnectorNewBase creates a new instance of ZetaConnectorNewBase, bound to a specific deployed contract. +func NewZetaConnectorNewBase(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNewBase, error) { + contract, err := bindZetaConnectorNewBase(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBase{ZetaConnectorNewBaseCaller: ZetaConnectorNewBaseCaller{contract: contract}, ZetaConnectorNewBaseTransactor: ZetaConnectorNewBaseTransactor{contract: contract}, ZetaConnectorNewBaseFilterer: ZetaConnectorNewBaseFilterer{contract: contract}}, nil +} + +// NewZetaConnectorNewBaseCaller creates a new read-only instance of ZetaConnectorNewBase, bound to a specific deployed contract. +func NewZetaConnectorNewBaseCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewBaseCaller, error) { + contract, err := bindZetaConnectorNewBase(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBaseCaller{contract: contract}, nil +} + +// NewZetaConnectorNewBaseTransactor creates a new write-only instance of ZetaConnectorNewBase, bound to a specific deployed contract. +func NewZetaConnectorNewBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewBaseTransactor, error) { + contract, err := bindZetaConnectorNewBase(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBaseTransactor{contract: contract}, nil +} + +// NewZetaConnectorNewBaseFilterer creates a new log filterer instance of ZetaConnectorNewBase, bound to a specific deployed contract. +func NewZetaConnectorNewBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewBaseFilterer, error) { + contract, err := bindZetaConnectorNewBase(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBaseFilterer{contract: contract}, nil +} + +// bindZetaConnectorNewBase binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNewBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNewBaseMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewBase.Contract.ZetaConnectorNewBaseCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.ZetaConnectorNewBaseTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.ZetaConnectorNewBaseTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewBase.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewBase.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewBase.Contract.Gateway(&_ZetaConnectorNewBase.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewBase.Contract.Gateway(&_ZetaConnectorNewBase.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewBase.contract.Call(opts, &out, "zetaToken") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewBase.Contract.ZetaToken(&_ZetaConnectorNewBase.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewBase.Contract.ZetaToken(&_ZetaConnectorNewBase.CallOpts) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewBase.contract.Transact(opts, "receiveTokens", amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.ReceiveTokens(&_ZetaConnectorNewBase.TransactOpts, amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.ReceiveTokens(&_ZetaConnectorNewBase.TransactOpts, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.contract.Transact(opts, "withdraw", to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.Withdraw(&_ZetaConnectorNewBase.TransactOpts, to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.Withdraw(&_ZetaConnectorNewBase.TransactOpts, to, amount, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.WithdrawAndCall(&_ZetaConnectorNewBase.TransactOpts, to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewBase.Contract.WithdrawAndCall(&_ZetaConnectorNewBase.TransactOpts, to, amount, data, internalSendHash) +} + +// ZetaConnectorNewBaseWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNewBase contract. +type ZetaConnectorNewBaseWithdrawIterator struct { + Event *ZetaConnectorNewBaseWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewBaseWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewBaseWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewBaseWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewBaseWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewBaseWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewBaseWithdraw represents a Withdraw event raised by the ZetaConnectorNewBase contract. +type ZetaConnectorNewBaseWithdraw struct { + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewBaseWithdrawIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewBase.contract.FilterLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBaseWithdrawIterator{contract: _ZetaConnectorNewBase.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewBaseWithdraw, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewBase.contract.WatchLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewBaseWithdraw) + if err := _ZetaConnectorNewBase.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewBaseWithdraw, error) { + event := new(ZetaConnectorNewBaseWithdraw) + if err := _ZetaConnectorNewBase.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZetaConnectorNewBaseWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNewBase contract. +type ZetaConnectorNewBaseWithdrawAndCallIterator struct { + Event *ZetaConnectorNewBaseWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewBaseWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewBaseWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewBaseWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewBaseWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewBaseWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewBaseWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNewBase contract. +type ZetaConnectorNewBaseWithdrawAndCall struct { + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewBaseWithdrawAndCallIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewBase.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewBaseWithdrawAndCallIterator{contract: _ZetaConnectorNewBase.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewBaseWithdrawAndCall, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewBase.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewBaseWithdrawAndCall) + if err := _ZetaConnectorNewBase.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewBase *ZetaConnectorNewBaseFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewBaseWithdrawAndCall, error) { + event := new(ZetaConnectorNewBaseWithdrawAndCall) + if err := _ZetaConnectorNewBase.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go b/pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go new file mode 100644 index 00000000..9921c205 --- /dev/null +++ b/pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go @@ -0,0 +1,619 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zetaconnectorneweth + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZetaConnectorNewEthMetaData contains all meta data concerning the ZetaConnectorNewEth contract. +var ZetaConnectorNewEthMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"receiveTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// ZetaConnectorNewEthABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNewEthMetaData.ABI instead. +var ZetaConnectorNewEthABI = ZetaConnectorNewEthMetaData.ABI + +// ZetaConnectorNewEthBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZetaConnectorNewEthMetaData.Bin instead. +var ZetaConnectorNewEthBin = ZetaConnectorNewEthMetaData.Bin + +// DeployZetaConnectorNewEth deploys a new Ethereum contract, binding an instance of ZetaConnectorNewEth to it. +func DeployZetaConnectorNewEth(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNewEth, error) { + parsed, err := ZetaConnectorNewEthMetaData.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(ZetaConnectorNewEthBin), backend, _gateway, _zetaToken) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ZetaConnectorNewEth{ZetaConnectorNewEthCaller: ZetaConnectorNewEthCaller{contract: contract}, ZetaConnectorNewEthTransactor: ZetaConnectorNewEthTransactor{contract: contract}, ZetaConnectorNewEthFilterer: ZetaConnectorNewEthFilterer{contract: contract}}, nil +} + +// ZetaConnectorNewEth is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNewEth struct { + ZetaConnectorNewEthCaller // Read-only binding to the contract + ZetaConnectorNewEthTransactor // Write-only binding to the contract + ZetaConnectorNewEthFilterer // Log filterer for contract events +} + +// ZetaConnectorNewEthCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNewEthCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewEthTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNewEthTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewEthFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNewEthFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewEthSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZetaConnectorNewEthSession struct { + Contract *ZetaConnectorNewEth // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewEthCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZetaConnectorNewEthCallerSession struct { + Contract *ZetaConnectorNewEthCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZetaConnectorNewEthTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZetaConnectorNewEthTransactorSession struct { + Contract *ZetaConnectorNewEthTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewEthRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNewEthRaw struct { + Contract *ZetaConnectorNewEth // Generic contract binding to access the raw methods on +} + +// ZetaConnectorNewEthCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNewEthCallerRaw struct { + Contract *ZetaConnectorNewEthCaller // Generic read-only contract binding to access the raw methods on +} + +// ZetaConnectorNewEthTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNewEthTransactorRaw struct { + Contract *ZetaConnectorNewEthTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZetaConnectorNewEth creates a new instance of ZetaConnectorNewEth, bound to a specific deployed contract. +func NewZetaConnectorNewEth(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNewEth, error) { + contract, err := bindZetaConnectorNewEth(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEth{ZetaConnectorNewEthCaller: ZetaConnectorNewEthCaller{contract: contract}, ZetaConnectorNewEthTransactor: ZetaConnectorNewEthTransactor{contract: contract}, ZetaConnectorNewEthFilterer: ZetaConnectorNewEthFilterer{contract: contract}}, nil +} + +// NewZetaConnectorNewEthCaller creates a new read-only instance of ZetaConnectorNewEth, bound to a specific deployed contract. +func NewZetaConnectorNewEthCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewEthCaller, error) { + contract, err := bindZetaConnectorNewEth(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEthCaller{contract: contract}, nil +} + +// NewZetaConnectorNewEthTransactor creates a new write-only instance of ZetaConnectorNewEth, bound to a specific deployed contract. +func NewZetaConnectorNewEthTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewEthTransactor, error) { + contract, err := bindZetaConnectorNewEth(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEthTransactor{contract: contract}, nil +} + +// NewZetaConnectorNewEthFilterer creates a new log filterer instance of ZetaConnectorNewEth, bound to a specific deployed contract. +func NewZetaConnectorNewEthFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewEthFilterer, error) { + contract, err := bindZetaConnectorNewEth(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEthFilterer{contract: contract}, nil +} + +// bindZetaConnectorNewEth binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNewEth(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNewEthMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewEth.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewEth.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewEth.Contract.Gateway(&_ZetaConnectorNewEth.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewEth.Contract.Gateway(&_ZetaConnectorNewEth.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewEth.contract.Call(opts, &out, "zetaToken") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewEth.Contract.ZetaToken(&_ZetaConnectorNewEth.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewEth.Contract.ZetaToken(&_ZetaConnectorNewEth.CallOpts) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewEth.contract.Transact(opts, "receiveTokens", amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.ReceiveTokens(&_ZetaConnectorNewEth.TransactOpts, amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.ReceiveTokens(&_ZetaConnectorNewEth.TransactOpts, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.contract.Transact(opts, "withdraw", to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.Withdraw(&_ZetaConnectorNewEth.TransactOpts, to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.Withdraw(&_ZetaConnectorNewEth.TransactOpts, to, amount, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.WithdrawAndCall(&_ZetaConnectorNewEth.TransactOpts, to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewEth.Contract.WithdrawAndCall(&_ZetaConnectorNewEth.TransactOpts, to, amount, data, internalSendHash) +} + +// ZetaConnectorNewEthWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNewEth contract. +type ZetaConnectorNewEthWithdrawIterator struct { + Event *ZetaConnectorNewEthWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewEthWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewEthWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewEthWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewEthWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewEthWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewEthWithdraw represents a Withdraw event raised by the ZetaConnectorNewEth contract. +type ZetaConnectorNewEthWithdraw struct { + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewEthWithdrawIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewEth.contract.FilterLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEthWithdrawIterator{contract: _ZetaConnectorNewEth.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewEthWithdraw, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewEth.contract.WatchLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewEthWithdraw) + if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewEthWithdraw, error) { + event := new(ZetaConnectorNewEthWithdraw) + if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZetaConnectorNewEthWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNewEth contract. +type ZetaConnectorNewEthWithdrawAndCallIterator struct { + Event *ZetaConnectorNewEthWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewEthWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewEthWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewEthWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNewEth contract. +type ZetaConnectorNewEthWithdrawAndCall struct { + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewEthWithdrawAndCallIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewEth.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewEthWithdrawAndCallIterator{contract: _ZetaConnectorNewEth.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewEthWithdrawAndCall, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewEth.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewEthWithdrawAndCall) + if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewEthWithdrawAndCall, error) { + event := new(ZetaConnectorNewEthWithdrawAndCall) + if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go b/pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go new file mode 100644 index 00000000..f353fb69 --- /dev/null +++ b/pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go @@ -0,0 +1,619 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package zetaconnectornewnoneth + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ZetaConnectorNewNonEthMetaData contains all meta data concerning the ZetaConnectorNewNonEth contract. +var ZetaConnectorNewNonEthMetaData = &bind.MetaData{ + ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"receiveTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", +} + +// ZetaConnectorNewNonEthABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNewNonEthMetaData.ABI instead. +var ZetaConnectorNewNonEthABI = ZetaConnectorNewNonEthMetaData.ABI + +// ZetaConnectorNewNonEthBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZetaConnectorNewNonEthMetaData.Bin instead. +var ZetaConnectorNewNonEthBin = ZetaConnectorNewNonEthMetaData.Bin + +// DeployZetaConnectorNewNonEth deploys a new Ethereum contract, binding an instance of ZetaConnectorNewNonEth to it. +func DeployZetaConnectorNewNonEth(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNewNonEth, error) { + parsed, err := ZetaConnectorNewNonEthMetaData.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(ZetaConnectorNewNonEthBin), backend, _gateway, _zetaToken) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ZetaConnectorNewNonEth{ZetaConnectorNewNonEthCaller: ZetaConnectorNewNonEthCaller{contract: contract}, ZetaConnectorNewNonEthTransactor: ZetaConnectorNewNonEthTransactor{contract: contract}, ZetaConnectorNewNonEthFilterer: ZetaConnectorNewNonEthFilterer{contract: contract}}, nil +} + +// ZetaConnectorNewNonEth is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNewNonEth struct { + ZetaConnectorNewNonEthCaller // Read-only binding to the contract + ZetaConnectorNewNonEthTransactor // Write-only binding to the contract + ZetaConnectorNewNonEthFilterer // Log filterer for contract events +} + +// ZetaConnectorNewNonEthCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNewNonEthCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewNonEthTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNewNonEthTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewNonEthFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNewNonEthFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ZetaConnectorNewNonEthSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ZetaConnectorNewNonEthSession struct { + Contract *ZetaConnectorNewNonEth // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewNonEthCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ZetaConnectorNewNonEthCallerSession struct { + Contract *ZetaConnectorNewNonEthCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ZetaConnectorNewNonEthTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ZetaConnectorNewNonEthTransactorSession struct { + Contract *ZetaConnectorNewNonEthTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ZetaConnectorNewNonEthRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNewNonEthRaw struct { + Contract *ZetaConnectorNewNonEth // Generic contract binding to access the raw methods on +} + +// ZetaConnectorNewNonEthCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNewNonEthCallerRaw struct { + Contract *ZetaConnectorNewNonEthCaller // Generic read-only contract binding to access the raw methods on +} + +// ZetaConnectorNewNonEthTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNewNonEthTransactorRaw struct { + Contract *ZetaConnectorNewNonEthTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewZetaConnectorNewNonEth creates a new instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. +func NewZetaConnectorNewNonEth(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNewNonEth, error) { + contract, err := bindZetaConnectorNewNonEth(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEth{ZetaConnectorNewNonEthCaller: ZetaConnectorNewNonEthCaller{contract: contract}, ZetaConnectorNewNonEthTransactor: ZetaConnectorNewNonEthTransactor{contract: contract}, ZetaConnectorNewNonEthFilterer: ZetaConnectorNewNonEthFilterer{contract: contract}}, nil +} + +// NewZetaConnectorNewNonEthCaller creates a new read-only instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. +func NewZetaConnectorNewNonEthCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewNonEthCaller, error) { + contract, err := bindZetaConnectorNewNonEth(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEthCaller{contract: contract}, nil +} + +// NewZetaConnectorNewNonEthTransactor creates a new write-only instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. +func NewZetaConnectorNewNonEthTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewNonEthTransactor, error) { + contract, err := bindZetaConnectorNewNonEth(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEthTransactor{contract: contract}, nil +} + +// NewZetaConnectorNewNonEthFilterer creates a new log filterer instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. +func NewZetaConnectorNewNonEthFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewNonEthFilterer, error) { + contract, err := bindZetaConnectorNewNonEth(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEthFilterer{contract: contract}, nil +} + +// bindZetaConnectorNewNonEth binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNewNonEth(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNewNonEthMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNewNonEth.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.contract.Transact(opts, method, params...) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewNonEth.contract.Call(opts, &out, "gateway") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewNonEth.Contract.Gateway(&_ZetaConnectorNewNonEth.CallOpts) +} + +// Gateway is a free data retrieval call binding the contract method 0x116191b6. +// +// Solidity: function gateway() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNewNonEth.Contract.Gateway(&_ZetaConnectorNewNonEth.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ZetaConnectorNewNonEth.contract.Call(opts, &out, "zetaToken") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewNonEth.Contract.ZetaToken(&_ZetaConnectorNewNonEth.CallOpts) +} + +// ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. +// +// Solidity: function zetaToken() view returns(address) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNewNonEth.Contract.ZetaToken(&_ZetaConnectorNewNonEth.CallOpts) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.contract.Transact(opts, "receiveTokens", amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.ReceiveTokens(&_ZetaConnectorNewNonEth.TransactOpts, amount) +} + +// ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. +// +// Solidity: function receiveTokens(uint256 amount) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.ReceiveTokens(&_ZetaConnectorNewNonEth.TransactOpts, amount) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.contract.Transact(opts, "withdraw", to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.Withdraw(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, internalSendHash) +} + +// Withdraw is a paid mutator transaction binding the contract method 0x106e6290. +// +// Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.Withdraw(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.WithdrawAndCall(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, data, internalSendHash) +} + +// WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. +// +// Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNewNonEth.Contract.WithdrawAndCall(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, data, internalSendHash) +} + +// ZetaConnectorNewNonEthWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNewNonEth contract. +type ZetaConnectorNewNonEthWithdrawIterator struct { + Event *ZetaConnectorNewNonEthWithdraw // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewNonEthWithdrawIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewNonEthWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewNonEthWithdraw) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewNonEthWithdrawIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewNonEthWithdrawIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewNonEthWithdraw represents a Withdraw event raised by the ZetaConnectorNewNonEth contract. +type ZetaConnectorNewNonEthWithdraw struct { + To common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewNonEthWithdrawIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewNonEth.contract.FilterLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEthWithdrawIterator{contract: _ZetaConnectorNewNonEth.contract, event: "Withdraw", logs: logs, sub: sub}, nil +} + +// WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewNonEthWithdraw, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewNonEth.contract.WatchLogs(opts, "Withdraw", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewNonEthWithdraw) + if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "Withdraw", 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 +} + +// ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. +// +// Solidity: event Withdraw(address indexed to, uint256 amount) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewNonEthWithdraw, error) { + event := new(ZetaConnectorNewNonEthWithdraw) + if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "Withdraw", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ZetaConnectorNewNonEthWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNewNonEth contract. +type ZetaConnectorNewNonEthWithdrawAndCallIterator struct { + Event *ZetaConnectorNewNonEthWithdrawAndCall // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewNonEthWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ZetaConnectorNewNonEthWithdrawAndCall) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ZetaConnectorNewNonEthWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNewNonEth contract. +type ZetaConnectorNewNonEthWithdrawAndCall struct { + To common.Address + Amount *big.Int + Data []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewNonEthWithdrawAndCallIterator, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewNonEth.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return &ZetaConnectorNewNonEthWithdrawAndCallIterator{contract: _ZetaConnectorNewNonEth.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil +} + +// WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewNonEthWithdrawAndCall, to []common.Address) (event.Subscription, error) { + + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ZetaConnectorNewNonEth.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ZetaConnectorNewNonEthWithdrawAndCall) + if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "WithdrawAndCall", 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 +} + +// ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. +// +// Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) +func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewNonEthWithdrawAndCall, error) { + event := new(ZetaConnectorNewNonEthWithdrawAndCall) + if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/typechain-types/contracts/prototypes/evm/IZetaNonEthNew.ts b/typechain-types/contracts/prototypes/evm/IZetaNonEthNew.ts new file mode 100644 index 00000000..eba3b2e0 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/IZetaNonEthNew.ts @@ -0,0 +1,425 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface IZetaNonEthNewInterface extends utils.Interface { + functions: { + "allowance(address,address)": FunctionFragment; + "approve(address,uint256)": FunctionFragment; + "balanceOf(address)": FunctionFragment; + "burnFrom(address,uint256)": FunctionFragment; + "mint(address,uint256,bytes32)": FunctionFragment; + "totalSupply()": FunctionFragment; + "transfer(address,uint256)": FunctionFragment; + "transferFrom(address,address,uint256)": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "allowance" + | "approve" + | "balanceOf" + | "burnFrom" + | "mint" + | "totalSupply" + | "transfer" + | "transferFrom" + ): FunctionFragment; + + encodeFunctionData( + functionFragment: "allowance", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "approve", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "balanceOf", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "burnFrom", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "mint", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "totalSupply", + values?: undefined + ): string; + encodeFunctionData( + functionFragment: "transfer", + values: [PromiseOrValue, PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "transferFrom", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + + decodeFunctionResult(functionFragment: "allowance", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "approve", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "burnFrom", data: BytesLike): Result; + decodeFunctionResult(functionFragment: "mint", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "totalSupply", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "transfer", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "transferFrom", + data: BytesLike + ): Result; + + events: { + "Approval(address,address,uint256)": EventFragment; + "Transfer(address,address,uint256)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Approval"): EventFragment; + getEvent(nameOrSignatureOrTopic: "Transfer"): EventFragment; +} + +export interface ApprovalEventObject { + owner: string; + spender: string; + value: BigNumber; +} +export type ApprovalEvent = TypedEvent< + [string, string, BigNumber], + ApprovalEventObject +>; + +export type ApprovalEventFilter = TypedEventFilter; + +export interface TransferEventObject { + from: string; + to: string; + value: BigNumber; +} +export type TransferEvent = TypedEvent< + [string, string, BigNumber], + TransferEventObject +>; + +export type TransferEventFilter = TypedEventFilter; + +export interface IZetaNonEthNew extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: IZetaNonEthNewInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise<[BigNumber]>; + + burnFrom( + account: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + mintee: PromiseOrValue, + value: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise<[BigNumber]>; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burnFrom( + account: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + mintee: PromiseOrValue, + value: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + callStatic: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burnFrom( + account: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + mint( + mintee: PromiseOrValue, + value: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + }; + + filters: { + "Approval(address,address,uint256)"( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + Approval( + owner?: PromiseOrValue | null, + spender?: PromiseOrValue | null, + value?: null + ): ApprovalEventFilter; + + "Transfer(address,address,uint256)"( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + Transfer( + from?: PromiseOrValue | null, + to?: PromiseOrValue | null, + value?: null + ): TransferEventFilter; + }; + + estimateGas: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burnFrom( + account: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + mintee: PromiseOrValue, + value: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; + + populateTransaction: { + allowance( + owner: PromiseOrValue, + spender: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + approve( + spender: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + balanceOf( + account: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + burnFrom( + account: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + mint( + mintee: PromiseOrValue, + value: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + totalSupply(overrides?: CallOverrides): Promise; + + transfer( + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + transferFrom( + from: PromiseOrValue, + to: PromiseOrValue, + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewBase.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewBase.ts new file mode 100644 index 00000000..e51de8e3 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewBase.ts @@ -0,0 +1,291 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZetaConnectorNewBaseInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "receiveTokens(uint256)": FunctionFragment; + "withdraw(address,uint256,bytes32)": FunctionFragment; + "withdrawAndCall(address,uint256,bytes,bytes32)": FunctionFragment; + "zetaToken()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "gateway" + | "receiveTokens" + | "withdraw" + | "withdrawAndCall" + | "zetaToken" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "receiveTokens", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "receiveTokens", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; + + events: { + "Withdraw(address,uint256)": EventFragment; + "WithdrawAndCall(address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ZetaConnectorNewBase extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZetaConnectorNewBaseInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise<[string]>; + }; + + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + filters: { + "Withdraw(address,uint256)"( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,uint256,bytes)"( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts new file mode 100644 index 00000000..8cc41d88 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts @@ -0,0 +1,291 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZetaConnectorNewEthInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "receiveTokens(uint256)": FunctionFragment; + "withdraw(address,uint256,bytes32)": FunctionFragment; + "withdrawAndCall(address,uint256,bytes,bytes32)": FunctionFragment; + "zetaToken()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "gateway" + | "receiveTokens" + | "withdraw" + | "withdrawAndCall" + | "zetaToken" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "receiveTokens", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "receiveTokens", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; + + events: { + "Withdraw(address,uint256)": EventFragment; + "WithdrawAndCall(address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ZetaConnectorNewEth extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZetaConnectorNewEthInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise<[string]>; + }; + + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + filters: { + "Withdraw(address,uint256)"( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,uint256,bytes)"( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts new file mode 100644 index 00000000..2b128dc1 --- /dev/null +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts @@ -0,0 +1,291 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import type { + BaseContract, + BigNumber, + BigNumberish, + BytesLike, + CallOverrides, + ContractTransaction, + Overrides, + PopulatedTransaction, + Signer, + utils, +} from "ethers"; +import type { + FunctionFragment, + Result, + EventFragment, +} from "@ethersproject/abi"; +import type { Listener, Provider } from "@ethersproject/providers"; +import type { + TypedEventFilter, + TypedEvent, + TypedListener, + OnEvent, + PromiseOrValue, +} from "../../../common"; + +export interface ZetaConnectorNewNonEthInterface extends utils.Interface { + functions: { + "gateway()": FunctionFragment; + "receiveTokens(uint256)": FunctionFragment; + "withdraw(address,uint256,bytes32)": FunctionFragment; + "withdrawAndCall(address,uint256,bytes,bytes32)": FunctionFragment; + "zetaToken()": FunctionFragment; + }; + + getFunction( + nameOrSignatureOrTopic: + | "gateway" + | "receiveTokens" + | "withdraw" + | "withdrawAndCall" + | "zetaToken" + ): FunctionFragment; + + encodeFunctionData(functionFragment: "gateway", values?: undefined): string; + encodeFunctionData( + functionFragment: "receiveTokens", + values: [PromiseOrValue] + ): string; + encodeFunctionData( + functionFragment: "withdraw", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData( + functionFragment: "withdrawAndCall", + values: [ + PromiseOrValue, + PromiseOrValue, + PromiseOrValue, + PromiseOrValue + ] + ): string; + encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; + + decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "receiveTokens", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; + decodeFunctionResult( + functionFragment: "withdrawAndCall", + data: BytesLike + ): Result; + decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; + + events: { + "Withdraw(address,uint256)": EventFragment; + "WithdrawAndCall(address,uint256,bytes)": EventFragment; + }; + + getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; + getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; +} + +export interface WithdrawEventObject { + to: string; + amount: BigNumber; +} +export type WithdrawEvent = TypedEvent< + [string, BigNumber], + WithdrawEventObject +>; + +export type WithdrawEventFilter = TypedEventFilter; + +export interface WithdrawAndCallEventObject { + to: string; + amount: BigNumber; + data: string; +} +export type WithdrawAndCallEvent = TypedEvent< + [string, BigNumber, string], + WithdrawAndCallEventObject +>; + +export type WithdrawAndCallEventFilter = TypedEventFilter; + +export interface ZetaConnectorNewNonEth extends BaseContract { + connect(signerOrProvider: Signer | Provider | string): this; + attach(addressOrName: string): this; + deployed(): Promise; + + interface: ZetaConnectorNewNonEthInterface; + + queryFilter( + event: TypedEventFilter, + fromBlockOrBlockhash?: string | number | undefined, + toBlock?: string | number | undefined + ): Promise>; + + listeners( + eventFilter?: TypedEventFilter + ): Array>; + listeners(eventName?: string): Array; + removeAllListeners( + eventFilter: TypedEventFilter + ): this; + removeAllListeners(eventName?: string): this; + off: OnEvent; + on: OnEvent; + once: OnEvent; + removeListener: OnEvent; + + functions: { + gateway(overrides?: CallOverrides): Promise<[string]>; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise<[string]>; + }; + + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + + callStatic: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: CallOverrides + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + filters: { + "Withdraw(address,uint256)"( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + Withdraw( + to?: PromiseOrValue | null, + amount?: null + ): WithdrawEventFilter; + + "WithdrawAndCall(address,uint256,bytes)"( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + WithdrawAndCall( + to?: PromiseOrValue | null, + amount?: null, + data?: null + ): WithdrawAndCallEventFilter; + }; + + estimateGas: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; + + populateTransaction: { + gateway(overrides?: CallOverrides): Promise; + + receiveTokens( + amount: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdraw( + to: PromiseOrValue, + amount: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + withdrawAndCall( + to: PromiseOrValue, + amount: PromiseOrValue, + data: PromiseOrValue, + internalSendHash: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise; + + zetaToken(overrides?: CallOverrides): Promise; + }; +} diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 9a11608e..4a445f5d 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -8,6 +8,9 @@ export type { iReceiverEvmSol }; export type { ERC20CustodyNew } from "./ERC20CustodyNew"; export type { GatewayEVM } from "./GatewayEVM"; export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; +export type { IZetaNonEthNew } from "./IZetaNonEthNew"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; -export type { ZetaConnectorNew } from "./ZetaConnectorNew"; +export type { ZetaConnectorNewBase } from "./ZetaConnectorNewBase"; +export type { ZetaConnectorNewEth } from "./ZetaConnectorNewEth"; +export type { ZetaConnectorNewNonEth } from "./ZetaConnectorNewNonEth"; diff --git a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts index 43dfec3f..02e01ac5 100644 --- a/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/evm/GatewayEVM__factory.ts @@ -573,7 +573,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/evm/IZetaNonEthNew__factory.ts b/typechain-types/factories/contracts/prototypes/evm/IZetaNonEthNew__factory.ts new file mode 100644 index 00000000..78938556 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/IZetaNonEthNew__factory.ts @@ -0,0 +1,250 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + IZetaNonEthNew, + IZetaNonEthNewInterface, +} from "../../../../contracts/prototypes/evm/IZetaNonEthNew"; + +const _abi = [ + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "owner", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "spender", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Approval", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "from", + type: "address", + }, + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "value", + type: "uint256", + }, + ], + name: "Transfer", + type: "event", + }, + { + inputs: [ + { + internalType: "address", + name: "owner", + type: "address", + }, + { + internalType: "address", + name: "spender", + type: "address", + }, + ], + name: "allowance", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "spender", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "approve", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + ], + name: "balanceOf", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "account", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "burnFrom", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "mintee", + type: "address", + }, + { + internalType: "uint256", + name: "value", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "mint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "totalSupply", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transfer", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "from", + type: "address", + }, + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "transferFrom", + outputs: [ + { + internalType: "bool", + name: "", + type: "bool", + }, + ], + stateMutability: "nonpayable", + type: "function", + }, +] as const; + +export class IZetaNonEthNew__factory { + static readonly abi = _abi; + static createInterface(): IZetaNonEthNewInterface { + return new utils.Interface(_abi) as IZetaNonEthNewInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): IZetaNonEthNew { + return new Contract(address, _abi, signerOrProvider) as IZetaNonEthNew; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory.ts new file mode 100644 index 00000000..642453cd --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory.ts @@ -0,0 +1,169 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ + +import { Contract, Signer, utils } from "ethers"; +import type { Provider } from "@ethersproject/providers"; +import type { + ZetaConnectorNewBase, + ZetaConnectorNewBaseInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNewBase"; + +const _abi = [ + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "receiveTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zetaToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +export class ZetaConnectorNewBase__factory { + static readonly abi = _abi; + static createInterface(): ZetaConnectorNewBaseInterface { + return new utils.Interface(_abi) as ZetaConnectorNewBaseInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNewBase { + return new Contract( + address, + _abi, + signerOrProvider + ) as ZetaConnectorNewBase; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory.ts new file mode 100644 index 00000000..87da7e03 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory.ts @@ -0,0 +1,226 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZetaConnectorNewEth, + ZetaConnectorNewEthInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNewEth"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + { + internalType: "address", + name: "_zetaToken", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "receiveTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zetaToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZetaConnectorNewEthConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZetaConnectorNewEthConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZetaConnectorNewEth__factory extends ContractFactory { + constructor(...args: ZetaConnectorNewEthConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + _gateway, + _zetaToken, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, _zetaToken, overrides || {}); + } + override attach(address: string): ZetaConnectorNewEth { + return super.attach(address) as ZetaConnectorNewEth; + } + override connect(signer: Signer): ZetaConnectorNewEth__factory { + return super.connect(signer) as ZetaConnectorNewEth__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZetaConnectorNewEthInterface { + return new utils.Interface(_abi) as ZetaConnectorNewEthInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNewEth { + return new Contract(address, _abi, signerOrProvider) as ZetaConnectorNewEth; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory.ts new file mode 100644 index 00000000..58920e9b --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory.ts @@ -0,0 +1,230 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZetaConnectorNewNonEth, + ZetaConnectorNewNonEthInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNewNonEth"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + { + internalType: "address", + name: "_zetaToken", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "receiveTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zetaToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "0x60c060405234801561001057600080fd5b50604051610c18380380610c1883398181016040528101906100329190610166565b81816001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614806100a35750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b156100da576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b81525050505050506101f4565b600081519050610160816101dd565b92915050565b6000806040838503121561017d5761017c6101d8565b5b600061018b85828601610151565b925050602061019c85828601610151565b9150509250929050565b60006101b1826101b8565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6101e6816101a6565b81146101f157600080fd5b50565b60805160601c60a05160601c6109d06102486000396000818160f601528181610204015281816102300152818161031b01526103f30152600081816101e00152818161026c01526102df01526109d06000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c8063106e62901461005c578063116191b61461007857806321e093b1146100965780635e3e9fef146100b4578063743e0c9b146100d0575b600080fd5b61007660048036038101906100719190610570565b6100ec565b005b6100806101de565b60405161008d91906107cd565b60405180910390f35b61009e610202565b6040516100ab9190610704565b60405180910390f35b6100ce60048036038101906100c991906105c3565b610226565b005b6100ea60048036038101906100e5919061064b565b6103f1565b005b6100f4610481565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16631e458bee8484846040518463ffffffff1660e01b815260040161015193929190610796565b600060405180830381600087803b15801561016b57600080fd5b505af115801561017f573d6000803e3d6000fd5b505050508273ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364836040516101c99190610808565b60405180910390a26101d96104d1565b505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b61022e610481565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16631e458bee7f000000000000000000000000000000000000000000000000000000000000000086846040518463ffffffff1660e01b81526004016102ab93929190610796565b600060405180830381600087803b1580156102c557600080fd5b505af11580156102d9573d6000803e3d6000fd5b505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635131ab597f0000000000000000000000000000000000000000000000000000000000000000878787876040518663ffffffff1660e01b815260040161035e95949392919061071f565b600060405180830381600087803b15801561037857600080fd5b505af115801561038c573d6000803e3d6000fd5b505050508473ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced8585856040516103da93929190610823565b60405180910390a26103ea6104d1565b5050505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166379cc679033836040518363ffffffff1660e01b815260040161044c92919061076d565b600060405180830381600087803b15801561046657600080fd5b505af115801561047a573d6000803e3d6000fd5b5050505050565b600260005414156104c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104be906107e8565b60405180910390fd5b6002600081905550565b6001600081905550565b6000813590506104ea81610955565b92915050565b6000813590506104ff8161096c565b92915050565b60008083601f84011261051b5761051a610907565b5b8235905067ffffffffffffffff81111561053857610537610902565b5b6020830191508360018202830111156105545761055361090c565b5b9250929050565b60008135905061056a81610983565b92915050565b60008060006060848603121561058957610588610916565b5b6000610597868287016104db565b93505060206105a88682870161055b565b92505060406105b9868287016104f0565b9150509250925092565b6000806000806000608086880312156105df576105de610916565b5b60006105ed888289016104db565b95505060206105fe8882890161055b565b945050604086013567ffffffffffffffff81111561061f5761061e610911565b5b61062b88828901610505565b9350935050606061063e888289016104f0565b9150509295509295909350565b60006020828403121561066157610660610916565b5b600061066f8482850161055b565b91505092915050565b61068181610877565b82525050565b61069081610889565b82525050565b60006106a28385610855565b93506106af8385846108f3565b6106b88361091b565b840190509392505050565b6106cc816108bd565b82525050565b60006106df601f83610866565b91506106ea8261092c565b602082019050919050565b6106fe816108b3565b82525050565b60006020820190506107196000830184610678565b92915050565b60006080820190506107346000830188610678565b6107416020830187610678565b61074e60408301866106f5565b8181036060830152610761818486610696565b90509695505050505050565b60006040820190506107826000830185610678565b61078f60208301846106f5565b9392505050565b60006060820190506107ab6000830186610678565b6107b860208301856106f5565b6107c56040830184610687565b949350505050565b60006020820190506107e260008301846106c3565b92915050565b60006020820190508181036000830152610801816106d2565b9050919050565b600060208201905061081d60008301846106f5565b92915050565b600060408201905061083860008301866106f5565b818103602083015261084b818486610696565b9050949350505050565b600082825260208201905092915050565b600082825260208201905092915050565b600061088282610893565b9050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006108c8826108cf565b9050919050565b60006108da826108e1565b9050919050565b60006108ec82610893565b9050919050565b82818337600083830152505050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b61095e81610877565b811461096957600080fd5b50565b61097581610889565b811461098057600080fd5b50565b61098c816108b3565b811461099757600080fd5b5056fea2646970667358221220af55d5f61addbf319928a723001d411ec2b726404eeedec369e4d204c7f69a1164736f6c63430008070033"; + +type ZetaConnectorNewNonEthConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZetaConnectorNewNonEthConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZetaConnectorNewNonEth__factory extends ContractFactory { + constructor(...args: ZetaConnectorNewNonEthConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + _gateway, + _zetaToken, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, _zetaToken, overrides || {}); + } + override attach(address: string): ZetaConnectorNewNonEth { + return super.attach(address) as ZetaConnectorNewNonEth; + } + override connect(signer: Signer): ZetaConnectorNewNonEth__factory { + return super.connect(signer) as ZetaConnectorNewNonEth__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZetaConnectorNewNonEthInterface { + return new utils.Interface(_abi) as ZetaConnectorNewNonEthInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNewNonEth { + return new Contract( + address, + _abi, + signerOrProvider + ) as ZetaConnectorNewNonEth; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index 31c7fa9c..788c8c3a 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -6,6 +6,9 @@ export * as iReceiverEvmSol from "./IReceiverEVM.sol"; export { ERC20CustodyNew__factory } from "./ERC20CustodyNew__factory"; export { GatewayEVM__factory } from "./GatewayEVM__factory"; export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory"; +export { IZetaNonEthNew__factory } from "./IZetaNonEthNew__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; -export { ZetaConnectorNew__factory } from "./ZetaConnectorNew__factory"; +export { ZetaConnectorNewBase__factory } from "./ZetaConnectorNewBase__factory"; +export { ZetaConnectorNewEth__factory } from "./ZetaConnectorNewEth__factory"; +export { ZetaConnectorNewNonEth__factory } from "./ZetaConnectorNewNonEth__factory"; diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 8bc18ce2..5697c0ed 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -360,6 +360,10 @@ declare module "hardhat/types/runtime" { name: "IReceiverEVMEvents", signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; + getContractFactory( + name: "IZetaNonEthNew", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "ReceiverEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -369,9 +373,17 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "ZetaConnectorNew", + name: "ZetaConnectorNewBase", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; + getContractFactory( + name: "ZetaConnectorNewEth", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; + getContractFactory( + name: "ZetaConnectorNewNonEth", + signerOrOptions?: ethers.Signer | FactoryOptions + ): Promise; getContractFactory( name: "GatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -908,6 +920,11 @@ declare module "hardhat/types/runtime" { address: string, signer?: ethers.Signer ): Promise; + getContractAt( + name: "IZetaNonEthNew", + address: string, + signer?: ethers.Signer + ): Promise; getContractAt( name: "ReceiverEVM", address: string, @@ -919,10 +936,20 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "ZetaConnectorNew", + name: "ZetaConnectorNewBase", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZetaConnectorNewEth", + address: string, + signer?: ethers.Signer + ): Promise; + getContractAt( + name: "ZetaConnectorNewNonEth", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "GatewayZEVM", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index 7416cf12..f472d97e 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -170,12 +170,18 @@ export type { IGatewayEVMEvents } from "./contracts/prototypes/evm/IGatewayEVM.s export { IGatewayEVMEvents__factory } from "./factories/contracts/prototypes/evm/IGatewayEVM.sol/IGatewayEVMEvents__factory"; export type { IReceiverEVMEvents } from "./contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents"; export { IReceiverEVMEvents__factory } from "./factories/contracts/prototypes/evm/IReceiverEVM.sol/IReceiverEVMEvents__factory"; +export type { IZetaNonEthNew } from "./contracts/prototypes/evm/IZetaNonEthNew"; +export { IZetaNonEthNew__factory } from "./factories/contracts/prototypes/evm/IZetaNonEthNew__factory"; export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; -export type { ZetaConnectorNew } from "./contracts/prototypes/evm/ZetaConnectorNew"; -export { ZetaConnectorNew__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNew__factory"; +export type { ZetaConnectorNewBase } from "./contracts/prototypes/evm/ZetaConnectorNewBase"; +export { ZetaConnectorNewBase__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory"; +export type { ZetaConnectorNewEth } from "./contracts/prototypes/evm/ZetaConnectorNewEth"; +export { ZetaConnectorNewEth__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory"; +export type { ZetaConnectorNewNonEth } from "./contracts/prototypes/evm/ZetaConnectorNewNonEth"; +export { ZetaConnectorNewNonEth__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM"; From b4b0ce367ac1dd57edaf071e41935736faf85e5b Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 19 Jul 2024 02:12:30 +0200 Subject: [PATCH 85/86] test fix --- test/prototypes/GatewayEVMUniswap.spec.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/prototypes/GatewayEVMUniswap.spec.ts b/test/prototypes/GatewayEVMUniswap.spec.ts index 0ba2cbf9..6f2eab70 100644 --- a/test/prototypes/GatewayEVMUniswap.spec.ts +++ b/test/prototypes/GatewayEVMUniswap.spec.ts @@ -59,7 +59,7 @@ describe("Uniswap Integration with GatewayEVM", function () { // Deploy contracts const Gateway = await ethers.getContractFactory("GatewayEVM"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNew"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNewNonEth"); const zeta = await TestERC20.deploy("Zeta", "ZETA"); gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", From 1cc8ad59a82e8fa6c1f81fa87574a82a317708db Mon Sep 17 00:00:00 2001 From: skosito Date: Fri, 19 Jul 2024 16:46:04 +0200 Subject: [PATCH 86/86] PR comments --- ...ctorNewEth.sol => ZetaConnectorNative.sol} | 2 +- ...wNonEth.sol => ZetaConnectorNonNative.sol} | 2 +- contracts/prototypes/zevm/GatewayZEVM.sol | 8 +- contracts/prototypes/zevm/IGatewayZEVM.sol | 1 - .../zetaconnectornative.go} | 290 +++++++++--------- .../zetaconnectornonnative.go} | 290 +++++++++--------- .../zevm/gatewayzevm.sol/gatewayzevm.go | 4 +- .../igatewayzevm.sol/igatewayzevmerrors.go | 2 +- .../zevm/senderzevm.sol/senderzevm.go | 2 +- test/prototypes/GatewayEVMUniswap.spec.ts | 2 +- testFoundry/GatewayEVM.t.sol | 10 +- testFoundry/GatewayEVMUpgrade.t.sol | 6 +- testFoundry/GatewayEVMZEVM.t.sol | 6 +- ...nectorNewEth.ts => ZetaConnectorNative.ts} | 6 +- .../prototypes/evm/ZetaConnectorNew.ts | 241 --------------- ...NewNonEth.ts => ZetaConnectorNonNative.ts} | 6 +- .../contracts/prototypes/evm/index.ts | 4 +- .../evm/ZetaConnectorNative__factory.ts | 226 ++++++++++++++ .../evm/ZetaConnectorNonNative__factory.ts | 230 ++++++++++++++ .../contracts/prototypes/evm/index.ts | 4 +- .../prototypes/zevm/GatewayZEVM__factory.ts | 4 +- .../IGatewayZEVMErrors__factory.ts | 5 - .../prototypes/zevm/SenderZEVM__factory.ts | 2 +- typechain-types/hardhat.d.ts | 24 +- typechain-types/index.ts | 8 +- 25 files changed, 800 insertions(+), 585 deletions(-) rename contracts/prototypes/evm/{ZetaConnectorNewEth.sol => ZetaConnectorNative.sol} (96%) rename contracts/prototypes/evm/{ZetaConnectorNewNonEth.sol => ZetaConnectorNonNative.sol} (95%) rename pkg/contracts/prototypes/evm/{zetaconnectorneweth.sol/zetaconnectorneweth.go => zetaconnectornative.sol/zetaconnectornative.go} (71%) rename pkg/contracts/prototypes/evm/{zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go => zetaconnectornonnative.sol/zetaconnectornonnative.go} (68%) rename typechain-types/contracts/prototypes/evm/{ZetaConnectorNewEth.ts => ZetaConnectorNative.ts} (98%) delete mode 100644 typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts rename typechain-types/contracts/prototypes/evm/{ZetaConnectorNewNonEth.ts => ZetaConnectorNonNative.ts} (97%) create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNative__factory.ts create mode 100644 typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNonNative__factory.ts diff --git a/contracts/prototypes/evm/ZetaConnectorNewEth.sol b/contracts/prototypes/evm/ZetaConnectorNative.sol similarity index 96% rename from contracts/prototypes/evm/ZetaConnectorNewEth.sol rename to contracts/prototypes/evm/ZetaConnectorNative.sol index c4f0ef65..ec333d59 100644 --- a/contracts/prototypes/evm/ZetaConnectorNewEth.sol +++ b/contracts/prototypes/evm/ZetaConnectorNative.sol @@ -5,7 +5,7 @@ import "./ZetaConnectorNewBase.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; -contract ZetaConnectorNewEth is ZetaConnectorNewBase { +contract ZetaConnectorNative is ZetaConnectorNewBase { using SafeERC20 for IERC20; constructor(address _gateway, address _zetaToken) diff --git a/contracts/prototypes/evm/ZetaConnectorNewNonEth.sol b/contracts/prototypes/evm/ZetaConnectorNonNative.sol similarity index 95% rename from contracts/prototypes/evm/ZetaConnectorNewNonEth.sol rename to contracts/prototypes/evm/ZetaConnectorNonNative.sol index 50d6a98e..47da0ec1 100644 --- a/contracts/prototypes/evm/ZetaConnectorNewNonEth.sol +++ b/contracts/prototypes/evm/ZetaConnectorNonNative.sol @@ -5,7 +5,7 @@ import "./ZetaConnectorNewBase.sol"; import "./IZetaNonEthNew.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol"; -contract ZetaConnectorNewNonEth is ZetaConnectorNewBase { +contract ZetaConnectorNonNative is ZetaConnectorNewBase { constructor(address _gateway, address _zetaToken) ZetaConnectorNewBase(_gateway, _zetaToken) {} diff --git a/contracts/prototypes/zevm/GatewayZEVM.sol b/contracts/prototypes/zevm/GatewayZEVM.sol index fa534a58..bdcad4d9 100644 --- a/contracts/prototypes/zevm/GatewayZEVM.sol +++ b/contracts/prototypes/zevm/GatewayZEVM.sol @@ -14,6 +14,8 @@ import "../../zevm/interfaces/IWZETA.sol"; // The GatewayZEVM contract is the endpoint to call smart contracts on omnichain // The contract doesn't hold any funds and should never have active allowances contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, OwnableUpgradeable, UUPSUpgradeable, ReentrancyGuard { + error ZeroAddress(); + address public constant FUNGIBLE_MODULE_ADDRESS = 0x735b14BB79463307AAcBED86DAf3322B1e6226aB; address public zetaToken; @@ -23,6 +25,10 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O } function initialize(address _zetaToken) public initializer { + if (_zetaToken == address(0)) { + revert ZeroAddress(); + } + __Ownable_init(); __UUPSUpgradeable_init(); zetaToken = _zetaToken; @@ -46,7 +52,7 @@ contract GatewayZEVM is IGatewayZEVMEvents, IGatewayZEVMErrors, Initializable, O } function _transferZETA(uint256 amount, address to) internal { - if (!IWETH9(zetaToken).transferFrom(msg.sender, address(this), amount)) revert ZetaTokenTransferFailed(); + if (!IWETH9(zetaToken).transferFrom(msg.sender, address(this), amount)) revert FailedZetaSent(); IWETH9(zetaToken).withdraw(amount); (bool sent, ) = to.call{value: amount}(""); if (!sent) revert FailedZetaSent(); diff --git a/contracts/prototypes/zevm/IGatewayZEVM.sol b/contracts/prototypes/zevm/IGatewayZEVM.sol index 3c1a95f1..b4607645 100644 --- a/contracts/prototypes/zevm/IGatewayZEVM.sol +++ b/contracts/prototypes/zevm/IGatewayZEVM.sol @@ -46,6 +46,5 @@ interface IGatewayZEVMErrors { error GasFeeTransferFailed(); error CallerIsNotFungibleModule(); error InvalidTarget(); - error ZetaTokenTransferFailed(); error FailedZetaSent(); } \ No newline at end of file diff --git a/pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go b/pkg/contracts/prototypes/evm/zetaconnectornative.sol/zetaconnectornative.go similarity index 71% rename from pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go rename to pkg/contracts/prototypes/evm/zetaconnectornative.sol/zetaconnectornative.go index 9921c205..be38ba51 100644 --- a/pkg/contracts/prototypes/evm/zetaconnectorneweth.sol/zetaconnectorneweth.go +++ b/pkg/contracts/prototypes/evm/zetaconnectornative.sol/zetaconnectornative.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package zetaconnectorneweth +package zetaconnectornative import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// ZetaConnectorNewEthMetaData contains all meta data concerning the ZetaConnectorNewEth contract. -var ZetaConnectorNewEthMetaData = &bind.MetaData{ +// ZetaConnectorNativeMetaData contains all meta data concerning the ZetaConnectorNative contract. +var ZetaConnectorNativeMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"receiveTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } -// ZetaConnectorNewEthABI is the input ABI used to generate the binding from. -// Deprecated: Use ZetaConnectorNewEthMetaData.ABI instead. -var ZetaConnectorNewEthABI = ZetaConnectorNewEthMetaData.ABI +// ZetaConnectorNativeABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNativeMetaData.ABI instead. +var ZetaConnectorNativeABI = ZetaConnectorNativeMetaData.ABI -// ZetaConnectorNewEthBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ZetaConnectorNewEthMetaData.Bin instead. -var ZetaConnectorNewEthBin = ZetaConnectorNewEthMetaData.Bin +// ZetaConnectorNativeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZetaConnectorNativeMetaData.Bin instead. +var ZetaConnectorNativeBin = ZetaConnectorNativeMetaData.Bin -// DeployZetaConnectorNewEth deploys a new Ethereum contract, binding an instance of ZetaConnectorNewEth to it. -func DeployZetaConnectorNewEth(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNewEth, error) { - parsed, err := ZetaConnectorNewEthMetaData.GetAbi() +// DeployZetaConnectorNative deploys a new Ethereum contract, binding an instance of ZetaConnectorNative to it. +func DeployZetaConnectorNative(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNative, error) { + parsed, err := ZetaConnectorNativeMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } @@ -53,111 +53,111 @@ func DeployZetaConnectorNewEth(auth *bind.TransactOpts, backend bind.ContractBac return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNewEthBin), backend, _gateway, _zetaToken) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNativeBin), backend, _gateway, _zetaToken) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &ZetaConnectorNewEth{ZetaConnectorNewEthCaller: ZetaConnectorNewEthCaller{contract: contract}, ZetaConnectorNewEthTransactor: ZetaConnectorNewEthTransactor{contract: contract}, ZetaConnectorNewEthFilterer: ZetaConnectorNewEthFilterer{contract: contract}}, nil + return address, tx, &ZetaConnectorNative{ZetaConnectorNativeCaller: ZetaConnectorNativeCaller{contract: contract}, ZetaConnectorNativeTransactor: ZetaConnectorNativeTransactor{contract: contract}, ZetaConnectorNativeFilterer: ZetaConnectorNativeFilterer{contract: contract}}, nil } -// ZetaConnectorNewEth is an auto generated Go binding around an Ethereum contract. -type ZetaConnectorNewEth struct { - ZetaConnectorNewEthCaller // Read-only binding to the contract - ZetaConnectorNewEthTransactor // Write-only binding to the contract - ZetaConnectorNewEthFilterer // Log filterer for contract events +// ZetaConnectorNative is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNative struct { + ZetaConnectorNativeCaller // Read-only binding to the contract + ZetaConnectorNativeTransactor // Write-only binding to the contract + ZetaConnectorNativeFilterer // Log filterer for contract events } -// ZetaConnectorNewEthCaller is an auto generated read-only Go binding around an Ethereum contract. -type ZetaConnectorNewEthCaller struct { +// ZetaConnectorNativeCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNativeCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewEthTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ZetaConnectorNewEthTransactor struct { +// ZetaConnectorNativeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNativeTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewEthFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ZetaConnectorNewEthFilterer struct { +// ZetaConnectorNativeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNativeFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewEthSession is an auto generated Go binding around an Ethereum contract, +// ZetaConnectorNativeSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ZetaConnectorNewEthSession struct { - Contract *ZetaConnectorNewEth // Generic contract binding to set the session for +type ZetaConnectorNativeSession struct { + Contract *ZetaConnectorNative // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ZetaConnectorNewEthCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// ZetaConnectorNativeCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ZetaConnectorNewEthCallerSession struct { - Contract *ZetaConnectorNewEthCaller // Generic contract caller binding to set the session for +type ZetaConnectorNativeCallerSession struct { + Contract *ZetaConnectorNativeCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } -// ZetaConnectorNewEthTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// ZetaConnectorNativeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ZetaConnectorNewEthTransactorSession struct { - Contract *ZetaConnectorNewEthTransactor // Generic contract transactor binding to set the session for +type ZetaConnectorNativeTransactorSession struct { + Contract *ZetaConnectorNativeTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ZetaConnectorNewEthRaw is an auto generated low-level Go binding around an Ethereum contract. -type ZetaConnectorNewEthRaw struct { - Contract *ZetaConnectorNewEth // Generic contract binding to access the raw methods on +// ZetaConnectorNativeRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNativeRaw struct { + Contract *ZetaConnectorNative // Generic contract binding to access the raw methods on } -// ZetaConnectorNewEthCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ZetaConnectorNewEthCallerRaw struct { - Contract *ZetaConnectorNewEthCaller // Generic read-only contract binding to access the raw methods on +// ZetaConnectorNativeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNativeCallerRaw struct { + Contract *ZetaConnectorNativeCaller // Generic read-only contract binding to access the raw methods on } -// ZetaConnectorNewEthTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ZetaConnectorNewEthTransactorRaw struct { - Contract *ZetaConnectorNewEthTransactor // Generic write-only contract binding to access the raw methods on +// ZetaConnectorNativeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNativeTransactorRaw struct { + Contract *ZetaConnectorNativeTransactor // Generic write-only contract binding to access the raw methods on } -// NewZetaConnectorNewEth creates a new instance of ZetaConnectorNewEth, bound to a specific deployed contract. -func NewZetaConnectorNewEth(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNewEth, error) { - contract, err := bindZetaConnectorNewEth(address, backend, backend, backend) +// NewZetaConnectorNative creates a new instance of ZetaConnectorNative, bound to a specific deployed contract. +func NewZetaConnectorNative(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNative, error) { + contract, err := bindZetaConnectorNative(address, backend, backend, backend) if err != nil { return nil, err } - return &ZetaConnectorNewEth{ZetaConnectorNewEthCaller: ZetaConnectorNewEthCaller{contract: contract}, ZetaConnectorNewEthTransactor: ZetaConnectorNewEthTransactor{contract: contract}, ZetaConnectorNewEthFilterer: ZetaConnectorNewEthFilterer{contract: contract}}, nil + return &ZetaConnectorNative{ZetaConnectorNativeCaller: ZetaConnectorNativeCaller{contract: contract}, ZetaConnectorNativeTransactor: ZetaConnectorNativeTransactor{contract: contract}, ZetaConnectorNativeFilterer: ZetaConnectorNativeFilterer{contract: contract}}, nil } -// NewZetaConnectorNewEthCaller creates a new read-only instance of ZetaConnectorNewEth, bound to a specific deployed contract. -func NewZetaConnectorNewEthCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewEthCaller, error) { - contract, err := bindZetaConnectorNewEth(address, caller, nil, nil) +// NewZetaConnectorNativeCaller creates a new read-only instance of ZetaConnectorNative, bound to a specific deployed contract. +func NewZetaConnectorNativeCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNativeCaller, error) { + contract, err := bindZetaConnectorNative(address, caller, nil, nil) if err != nil { return nil, err } - return &ZetaConnectorNewEthCaller{contract: contract}, nil + return &ZetaConnectorNativeCaller{contract: contract}, nil } -// NewZetaConnectorNewEthTransactor creates a new write-only instance of ZetaConnectorNewEth, bound to a specific deployed contract. -func NewZetaConnectorNewEthTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewEthTransactor, error) { - contract, err := bindZetaConnectorNewEth(address, nil, transactor, nil) +// NewZetaConnectorNativeTransactor creates a new write-only instance of ZetaConnectorNative, bound to a specific deployed contract. +func NewZetaConnectorNativeTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNativeTransactor, error) { + contract, err := bindZetaConnectorNative(address, nil, transactor, nil) if err != nil { return nil, err } - return &ZetaConnectorNewEthTransactor{contract: contract}, nil + return &ZetaConnectorNativeTransactor{contract: contract}, nil } -// NewZetaConnectorNewEthFilterer creates a new log filterer instance of ZetaConnectorNewEth, bound to a specific deployed contract. -func NewZetaConnectorNewEthFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewEthFilterer, error) { - contract, err := bindZetaConnectorNewEth(address, nil, nil, filterer) +// NewZetaConnectorNativeFilterer creates a new log filterer instance of ZetaConnectorNative, bound to a specific deployed contract. +func NewZetaConnectorNativeFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNativeFilterer, error) { + contract, err := bindZetaConnectorNative(address, nil, nil, filterer) if err != nil { return nil, err } - return &ZetaConnectorNewEthFilterer{contract: contract}, nil + return &ZetaConnectorNativeFilterer{contract: contract}, nil } -// bindZetaConnectorNewEth binds a generic wrapper to an already deployed contract. -func bindZetaConnectorNewEth(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ZetaConnectorNewEthMetaData.GetAbi() +// bindZetaConnectorNative binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNative(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNativeMetaData.GetAbi() if err != nil { return nil, err } @@ -168,46 +168,46 @@ func bindZetaConnectorNewEth(address common.Address, caller bind.ContractCaller, // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthCaller.contract.Call(opts, result, method, params...) +func (_ZetaConnectorNative *ZetaConnectorNativeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNative.Contract.ZetaConnectorNativeCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthTransactor.contract.Transfer(opts) +func (_ZetaConnectorNative *ZetaConnectorNativeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.ZetaConnectorNativeTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.ZetaConnectorNewEthTransactor.contract.Transact(opts, method, params...) +func (_ZetaConnectorNative *ZetaConnectorNativeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.ZetaConnectorNativeTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNewEth.Contract.contract.Call(opts, result, method, params...) +func (_ZetaConnectorNative *ZetaConnectorNativeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNative.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.contract.Transfer(opts) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.contract.Transact(opts, method, params...) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.contract.Transact(opts, method, params...) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ZetaConnectorNewEth.contract.Call(opts, &out, "gateway") + err := _ZetaConnectorNative.contract.Call(opts, &out, "gateway") if err != nil { return *new(common.Address), err @@ -222,23 +222,23 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) Gateway(opts *bind.CallOp // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) Gateway() (common.Address, error) { - return _ZetaConnectorNewEth.Contract.Gateway(&_ZetaConnectorNewEth.CallOpts) +func (_ZetaConnectorNative *ZetaConnectorNativeSession) Gateway() (common.Address, error) { + return _ZetaConnectorNative.Contract.Gateway(&_ZetaConnectorNative.CallOpts) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerSession) Gateway() (common.Address, error) { - return _ZetaConnectorNewEth.Contract.Gateway(&_ZetaConnectorNewEth.CallOpts) +func (_ZetaConnectorNative *ZetaConnectorNativeCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNative.Contract.Gateway(&_ZetaConnectorNative.CallOpts) } // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ZetaConnectorNewEth.contract.Call(opts, &out, "zetaToken") + err := _ZetaConnectorNative.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -253,83 +253,83 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthCaller) ZetaToken(opts *bind.Call // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNewEth.Contract.ZetaToken(&_ZetaConnectorNewEth.CallOpts) +func (_ZetaConnectorNative *ZetaConnectorNativeSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNative.Contract.ZetaToken(&_ZetaConnectorNative.CallOpts) } // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthCallerSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNewEth.Contract.ZetaToken(&_ZetaConnectorNewEth.CallOpts) +func (_ZetaConnectorNative *ZetaConnectorNativeCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNative.Contract.ZetaToken(&_ZetaConnectorNative.CallOpts) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewEth.contract.Transact(opts, "receiveTokens", amount) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNative.contract.Transact(opts, "receiveTokens", amount) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.ReceiveTokens(&_ZetaConnectorNewEth.TransactOpts, amount) +func (_ZetaConnectorNative *ZetaConnectorNativeSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.ReceiveTokens(&_ZetaConnectorNative.TransactOpts, amount) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.ReceiveTokens(&_ZetaConnectorNewEth.TransactOpts, amount) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.ReceiveTokens(&_ZetaConnectorNative.TransactOpts, amount) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.contract.Transact(opts, "withdraw", to, amount, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.contract.Transact(opts, "withdraw", to, amount, internalSendHash) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.Withdraw(&_ZetaConnectorNewEth.TransactOpts, to, amount, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.Withdraw(&_ZetaConnectorNative.TransactOpts, to, amount, internalSendHash) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.Withdraw(&_ZetaConnectorNewEth.TransactOpts, to, amount, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.Withdraw(&_ZetaConnectorNative.TransactOpts, to, amount, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.WithdrawAndCall(&_ZetaConnectorNewEth.TransactOpts, to, amount, data, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.WithdrawAndCall(&_ZetaConnectorNative.TransactOpts, to, amount, data, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewEth *ZetaConnectorNewEthTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewEth.Contract.WithdrawAndCall(&_ZetaConnectorNewEth.TransactOpts, to, amount, data, internalSendHash) +func (_ZetaConnectorNative *ZetaConnectorNativeTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNative.Contract.WithdrawAndCall(&_ZetaConnectorNative.TransactOpts, to, amount, data, internalSendHash) } -// ZetaConnectorNewEthWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNewEth contract. -type ZetaConnectorNewEthWithdrawIterator struct { - Event *ZetaConnectorNewEthWithdraw // Event containing the contract specifics and raw log +// ZetaConnectorNativeWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNative contract. +type ZetaConnectorNativeWithdrawIterator struct { + Event *ZetaConnectorNativeWithdraw // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -343,7 +343,7 @@ type ZetaConnectorNewEthWithdrawIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewEthWithdrawIterator) Next() bool { +func (it *ZetaConnectorNativeWithdrawIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -352,7 +352,7 @@ func (it *ZetaConnectorNewEthWithdrawIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewEthWithdraw) + it.Event = new(ZetaConnectorNativeWithdraw) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -367,7 +367,7 @@ func (it *ZetaConnectorNewEthWithdrawIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewEthWithdraw) + it.Event = new(ZetaConnectorNativeWithdraw) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -383,19 +383,19 @@ func (it *ZetaConnectorNewEthWithdrawIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewEthWithdrawIterator) Error() error { +func (it *ZetaConnectorNativeWithdrawIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ZetaConnectorNewEthWithdrawIterator) Close() error { +func (it *ZetaConnectorNativeWithdrawIterator) Close() error { it.sub.Unsubscribe() return nil } -// ZetaConnectorNewEthWithdraw represents a Withdraw event raised by the ZetaConnectorNewEth contract. -type ZetaConnectorNewEthWithdraw struct { +// ZetaConnectorNativeWithdraw represents a Withdraw event raised by the ZetaConnectorNative contract. +type ZetaConnectorNativeWithdraw struct { To common.Address Amount *big.Int Raw types.Log // Blockchain specific contextual infos @@ -404,31 +404,31 @@ type ZetaConnectorNewEthWithdraw struct { // FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewEthWithdrawIterator, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNativeWithdrawIterator, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewEth.contract.FilterLogs(opts, "Withdraw", toRule) + logs, sub, err := _ZetaConnectorNative.contract.FilterLogs(opts, "Withdraw", toRule) if err != nil { return nil, err } - return &ZetaConnectorNewEthWithdrawIterator{contract: _ZetaConnectorNewEth.contract, event: "Withdraw", logs: logs, sub: sub}, nil + return &ZetaConnectorNativeWithdrawIterator{contract: _ZetaConnectorNative.contract, event: "Withdraw", logs: logs, sub: sub}, nil } // WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewEthWithdraw, to []common.Address) (event.Subscription, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNativeWithdraw, to []common.Address) (event.Subscription, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewEth.contract.WatchLogs(opts, "Withdraw", toRule) + logs, sub, err := _ZetaConnectorNative.contract.WatchLogs(opts, "Withdraw", toRule) if err != nil { return nil, err } @@ -438,8 +438,8 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdraw(opts *bin select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewEthWithdraw) - if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "Withdraw", log); err != nil { + event := new(ZetaConnectorNativeWithdraw) + if err := _ZetaConnectorNative.contract.UnpackLog(event, "Withdraw", log); err != nil { return err } event.Raw = log @@ -463,18 +463,18 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdraw(opts *bin // ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewEthWithdraw, error) { - event := new(ZetaConnectorNewEthWithdraw) - if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "Withdraw", log); err != nil { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNativeWithdraw, error) { + event := new(ZetaConnectorNativeWithdraw) + if err := _ZetaConnectorNative.contract.UnpackLog(event, "Withdraw", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ZetaConnectorNewEthWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNewEth contract. -type ZetaConnectorNewEthWithdrawAndCallIterator struct { - Event *ZetaConnectorNewEthWithdrawAndCall // Event containing the contract specifics and raw log +// ZetaConnectorNativeWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNative contract. +type ZetaConnectorNativeWithdrawAndCallIterator struct { + Event *ZetaConnectorNativeWithdrawAndCall // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -488,7 +488,7 @@ type ZetaConnectorNewEthWithdrawAndCallIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Next() bool { +func (it *ZetaConnectorNativeWithdrawAndCallIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -497,7 +497,7 @@ func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewEthWithdrawAndCall) + it.Event = new(ZetaConnectorNativeWithdrawAndCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -512,7 +512,7 @@ func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewEthWithdrawAndCall) + it.Event = new(ZetaConnectorNativeWithdrawAndCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -528,19 +528,19 @@ func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Error() error { +func (it *ZetaConnectorNativeWithdrawAndCallIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ZetaConnectorNewEthWithdrawAndCallIterator) Close() error { +func (it *ZetaConnectorNativeWithdrawAndCallIterator) Close() error { it.sub.Unsubscribe() return nil } -// ZetaConnectorNewEthWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNewEth contract. -type ZetaConnectorNewEthWithdrawAndCall struct { +// ZetaConnectorNativeWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNative contract. +type ZetaConnectorNativeWithdrawAndCall struct { To common.Address Amount *big.Int Data []byte @@ -550,31 +550,31 @@ type ZetaConnectorNewEthWithdrawAndCall struct { // FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewEthWithdrawAndCallIterator, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNativeWithdrawAndCallIterator, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewEth.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + logs, sub, err := _ZetaConnectorNative.contract.FilterLogs(opts, "WithdrawAndCall", toRule) if err != nil { return nil, err } - return &ZetaConnectorNewEthWithdrawAndCallIterator{contract: _ZetaConnectorNewEth.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil + return &ZetaConnectorNativeWithdrawAndCallIterator{contract: _ZetaConnectorNative.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil } // WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewEthWithdrawAndCall, to []common.Address) (event.Subscription, error) { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNativeWithdrawAndCall, to []common.Address) (event.Subscription, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewEth.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + logs, sub, err := _ZetaConnectorNative.contract.WatchLogs(opts, "WithdrawAndCall", toRule) if err != nil { return nil, err } @@ -584,8 +584,8 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdrawAndCall(op select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewEthWithdrawAndCall) - if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + event := new(ZetaConnectorNativeWithdrawAndCall) + if err := _ZetaConnectorNative.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { return err } event.Raw = log @@ -609,9 +609,9 @@ func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) WatchWithdrawAndCall(op // ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewEth *ZetaConnectorNewEthFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewEthWithdrawAndCall, error) { - event := new(ZetaConnectorNewEthWithdrawAndCall) - if err := _ZetaConnectorNewEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { +func (_ZetaConnectorNative *ZetaConnectorNativeFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNativeWithdrawAndCall, error) { + event := new(ZetaConnectorNativeWithdrawAndCall) + if err := _ZetaConnectorNative.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go b/pkg/contracts/prototypes/evm/zetaconnectornonnative.sol/zetaconnectornonnative.go similarity index 68% rename from pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go rename to pkg/contracts/prototypes/evm/zetaconnectornonnative.sol/zetaconnectornonnative.go index f353fb69..733ba862 100644 --- a/pkg/contracts/prototypes/evm/zetaconnectornewnoneth.sol/zetaconnectornewnoneth.go +++ b/pkg/contracts/prototypes/evm/zetaconnectornonnative.sol/zetaconnectornonnative.go @@ -1,7 +1,7 @@ // Code generated - DO NOT EDIT. // This file is a generated binding and any manual changes will be lost. -package zetaconnectornewnoneth +package zetaconnectornonnative import ( "errors" @@ -29,23 +29,23 @@ var ( _ = abi.ConvertType ) -// ZetaConnectorNewNonEthMetaData contains all meta data concerning the ZetaConnectorNewNonEth contract. -var ZetaConnectorNewNonEthMetaData = &bind.MetaData{ +// ZetaConnectorNonNativeMetaData contains all meta data concerning the ZetaConnectorNonNative contract. +var ZetaConnectorNonNativeMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Withdraw\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"WithdrawAndCall\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"contractIGatewayEVM\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"receiveTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"internalSendHash\",\"type\":\"bytes32\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + Bin: "0x60c060405234801561001057600080fd5b50604051610c18380380610c1883398181016040528101906100329190610166565b81816001600081905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614806100a35750600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16145b156100da576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8173ffffffffffffffffffffffffffffffffffffffff1660808173ffffffffffffffffffffffffffffffffffffffff1660601b815250508073ffffffffffffffffffffffffffffffffffffffff1660a08173ffffffffffffffffffffffffffffffffffffffff1660601b81525050505050506101f4565b600081519050610160816101dd565b92915050565b6000806040838503121561017d5761017c6101d8565b5b600061018b85828601610151565b925050602061019c85828601610151565b9150509250929050565b60006101b1826101b8565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6101e6816101a6565b81146101f157600080fd5b50565b60805160601c60a05160601c6109d06102486000396000818160f601528181610204015281816102300152818161031b01526103f30152600081816101e00152818161026c01526102df01526109d06000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c8063106e62901461005c578063116191b61461007857806321e093b1146100965780635e3e9fef146100b4578063743e0c9b146100d0575b600080fd5b61007660048036038101906100719190610570565b6100ec565b005b6100806101de565b60405161008d91906107cd565b60405180910390f35b61009e610202565b6040516100ab9190610704565b60405180910390f35b6100ce60048036038101906100c991906105c3565b610226565b005b6100ea60048036038101906100e5919061064b565b6103f1565b005b6100f4610481565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16631e458bee8484846040518463ffffffff1660e01b815260040161015193929190610796565b600060405180830381600087803b15801561016b57600080fd5b505af115801561017f573d6000803e3d6000fd5b505050508273ffffffffffffffffffffffffffffffffffffffff167f884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364836040516101c99190610808565b60405180910390a26101d96104d1565b505050565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b61022e610481565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16631e458bee7f000000000000000000000000000000000000000000000000000000000000000086846040518463ffffffff1660e01b81526004016102ab93929190610796565b600060405180830381600087803b1580156102c557600080fd5b505af11580156102d9573d6000803e3d6000fd5b505050507f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16635131ab597f0000000000000000000000000000000000000000000000000000000000000000878787876040518663ffffffff1660e01b815260040161035e95949392919061071f565b600060405180830381600087803b15801561037857600080fd5b505af115801561038c573d6000803e3d6000fd5b505050508473ffffffffffffffffffffffffffffffffffffffff167f7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced8585856040516103da93929190610823565b60405180910390a26103ea6104d1565b5050505050565b7f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff166379cc679033836040518363ffffffff1660e01b815260040161044c92919061076d565b600060405180830381600087803b15801561046657600080fd5b505af115801561047a573d6000803e3d6000fd5b5050505050565b600260005414156104c7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016104be906107e8565b60405180910390fd5b6002600081905550565b6001600081905550565b6000813590506104ea81610955565b92915050565b6000813590506104ff8161096c565b92915050565b60008083601f84011261051b5761051a610907565b5b8235905067ffffffffffffffff81111561053857610537610902565b5b6020830191508360018202830111156105545761055361090c565b5b9250929050565b60008135905061056a81610983565b92915050565b60008060006060848603121561058957610588610916565b5b6000610597868287016104db565b93505060206105a88682870161055b565b92505060406105b9868287016104f0565b9150509250925092565b6000806000806000608086880312156105df576105de610916565b5b60006105ed888289016104db565b95505060206105fe8882890161055b565b945050604086013567ffffffffffffffff81111561061f5761061e610911565b5b61062b88828901610505565b9350935050606061063e888289016104f0565b9150509295509295909350565b60006020828403121561066157610660610916565b5b600061066f8482850161055b565b91505092915050565b61068181610877565b82525050565b61069081610889565b82525050565b60006106a28385610855565b93506106af8385846108f3565b6106b88361091b565b840190509392505050565b6106cc816108bd565b82525050565b60006106df601f83610866565b91506106ea8261092c565b602082019050919050565b6106fe816108b3565b82525050565b60006020820190506107196000830184610678565b92915050565b60006080820190506107346000830188610678565b6107416020830187610678565b61074e60408301866106f5565b8181036060830152610761818486610696565b90509695505050505050565b60006040820190506107826000830185610678565b61078f60208301846106f5565b9392505050565b60006060820190506107ab6000830186610678565b6107b860208301856106f5565b6107c56040830184610687565b949350505050565b60006020820190506107e260008301846106c3565b92915050565b60006020820190508181036000830152610801816106d2565b9050919050565b600060208201905061081d60008301846106f5565b92915050565b600060408201905061083860008301866106f5565b818103602083015261084b818486610696565b9050949350505050565b600082825260208201905092915050565b600082825260208201905092915050565b600061088282610893565b9050919050565b6000819050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b60006108c8826108cf565b9050919050565b60006108da826108e1565b9050919050565b60006108ec82610893565b9050919050565b82818337600083830152505050565b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b61095e81610877565b811461096957600080fd5b50565b61097581610889565b811461098057600080fd5b50565b61098c816108b3565b811461099757600080fd5b5056fea26469706673582212207f7878844260a362b1a202d1ea2396eb37afd371a9bda78bcbd9e76d6aa5d35264736f6c63430008070033", } -// ZetaConnectorNewNonEthABI is the input ABI used to generate the binding from. -// Deprecated: Use ZetaConnectorNewNonEthMetaData.ABI instead. -var ZetaConnectorNewNonEthABI = ZetaConnectorNewNonEthMetaData.ABI +// ZetaConnectorNonNativeABI is the input ABI used to generate the binding from. +// Deprecated: Use ZetaConnectorNonNativeMetaData.ABI instead. +var ZetaConnectorNonNativeABI = ZetaConnectorNonNativeMetaData.ABI -// ZetaConnectorNewNonEthBin is the compiled bytecode used for deploying new contracts. -// Deprecated: Use ZetaConnectorNewNonEthMetaData.Bin instead. -var ZetaConnectorNewNonEthBin = ZetaConnectorNewNonEthMetaData.Bin +// ZetaConnectorNonNativeBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ZetaConnectorNonNativeMetaData.Bin instead. +var ZetaConnectorNonNativeBin = ZetaConnectorNonNativeMetaData.Bin -// DeployZetaConnectorNewNonEth deploys a new Ethereum contract, binding an instance of ZetaConnectorNewNonEth to it. -func DeployZetaConnectorNewNonEth(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNewNonEth, error) { - parsed, err := ZetaConnectorNewNonEthMetaData.GetAbi() +// DeployZetaConnectorNonNative deploys a new Ethereum contract, binding an instance of ZetaConnectorNonNative to it. +func DeployZetaConnectorNonNative(auth *bind.TransactOpts, backend bind.ContractBackend, _gateway common.Address, _zetaToken common.Address) (common.Address, *types.Transaction, *ZetaConnectorNonNative, error) { + parsed, err := ZetaConnectorNonNativeMetaData.GetAbi() if err != nil { return common.Address{}, nil, nil, err } @@ -53,111 +53,111 @@ func DeployZetaConnectorNewNonEth(auth *bind.TransactOpts, backend bind.Contract return common.Address{}, nil, nil, errors.New("GetABI returned nil") } - address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNewNonEthBin), backend, _gateway, _zetaToken) + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ZetaConnectorNonNativeBin), backend, _gateway, _zetaToken) if err != nil { return common.Address{}, nil, nil, err } - return address, tx, &ZetaConnectorNewNonEth{ZetaConnectorNewNonEthCaller: ZetaConnectorNewNonEthCaller{contract: contract}, ZetaConnectorNewNonEthTransactor: ZetaConnectorNewNonEthTransactor{contract: contract}, ZetaConnectorNewNonEthFilterer: ZetaConnectorNewNonEthFilterer{contract: contract}}, nil + return address, tx, &ZetaConnectorNonNative{ZetaConnectorNonNativeCaller: ZetaConnectorNonNativeCaller{contract: contract}, ZetaConnectorNonNativeTransactor: ZetaConnectorNonNativeTransactor{contract: contract}, ZetaConnectorNonNativeFilterer: ZetaConnectorNonNativeFilterer{contract: contract}}, nil } -// ZetaConnectorNewNonEth is an auto generated Go binding around an Ethereum contract. -type ZetaConnectorNewNonEth struct { - ZetaConnectorNewNonEthCaller // Read-only binding to the contract - ZetaConnectorNewNonEthTransactor // Write-only binding to the contract - ZetaConnectorNewNonEthFilterer // Log filterer for contract events +// ZetaConnectorNonNative is an auto generated Go binding around an Ethereum contract. +type ZetaConnectorNonNative struct { + ZetaConnectorNonNativeCaller // Read-only binding to the contract + ZetaConnectorNonNativeTransactor // Write-only binding to the contract + ZetaConnectorNonNativeFilterer // Log filterer for contract events } -// ZetaConnectorNewNonEthCaller is an auto generated read-only Go binding around an Ethereum contract. -type ZetaConnectorNewNonEthCaller struct { +// ZetaConnectorNonNativeCaller is an auto generated read-only Go binding around an Ethereum contract. +type ZetaConnectorNonNativeCaller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewNonEthTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ZetaConnectorNewNonEthTransactor struct { +// ZetaConnectorNonNativeTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ZetaConnectorNonNativeTransactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewNonEthFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ZetaConnectorNewNonEthFilterer struct { +// ZetaConnectorNonNativeFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ZetaConnectorNonNativeFilterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ZetaConnectorNewNonEthSession is an auto generated Go binding around an Ethereum contract, +// ZetaConnectorNonNativeSession is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ZetaConnectorNewNonEthSession struct { - Contract *ZetaConnectorNewNonEth // Generic contract binding to set the session for +type ZetaConnectorNonNativeSession struct { + Contract *ZetaConnectorNonNative // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ZetaConnectorNewNonEthCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// ZetaConnectorNonNativeCallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ZetaConnectorNewNonEthCallerSession struct { - Contract *ZetaConnectorNewNonEthCaller // Generic contract caller binding to set the session for +type ZetaConnectorNonNativeCallerSession struct { + Contract *ZetaConnectorNonNativeCaller // Generic contract caller binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session } -// ZetaConnectorNewNonEthTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// ZetaConnectorNonNativeTransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ZetaConnectorNewNonEthTransactorSession struct { - Contract *ZetaConnectorNewNonEthTransactor // Generic contract transactor binding to set the session for +type ZetaConnectorNonNativeTransactorSession struct { + Contract *ZetaConnectorNonNativeTransactor // Generic contract transactor binding to set the session for TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ZetaConnectorNewNonEthRaw is an auto generated low-level Go binding around an Ethereum contract. -type ZetaConnectorNewNonEthRaw struct { - Contract *ZetaConnectorNewNonEth // Generic contract binding to access the raw methods on +// ZetaConnectorNonNativeRaw is an auto generated low-level Go binding around an Ethereum contract. +type ZetaConnectorNonNativeRaw struct { + Contract *ZetaConnectorNonNative // Generic contract binding to access the raw methods on } -// ZetaConnectorNewNonEthCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ZetaConnectorNewNonEthCallerRaw struct { - Contract *ZetaConnectorNewNonEthCaller // Generic read-only contract binding to access the raw methods on +// ZetaConnectorNonNativeCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ZetaConnectorNonNativeCallerRaw struct { + Contract *ZetaConnectorNonNativeCaller // Generic read-only contract binding to access the raw methods on } -// ZetaConnectorNewNonEthTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ZetaConnectorNewNonEthTransactorRaw struct { - Contract *ZetaConnectorNewNonEthTransactor // Generic write-only contract binding to access the raw methods on +// ZetaConnectorNonNativeTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ZetaConnectorNonNativeTransactorRaw struct { + Contract *ZetaConnectorNonNativeTransactor // Generic write-only contract binding to access the raw methods on } -// NewZetaConnectorNewNonEth creates a new instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. -func NewZetaConnectorNewNonEth(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNewNonEth, error) { - contract, err := bindZetaConnectorNewNonEth(address, backend, backend, backend) +// NewZetaConnectorNonNative creates a new instance of ZetaConnectorNonNative, bound to a specific deployed contract. +func NewZetaConnectorNonNative(address common.Address, backend bind.ContractBackend) (*ZetaConnectorNonNative, error) { + contract, err := bindZetaConnectorNonNative(address, backend, backend, backend) if err != nil { return nil, err } - return &ZetaConnectorNewNonEth{ZetaConnectorNewNonEthCaller: ZetaConnectorNewNonEthCaller{contract: contract}, ZetaConnectorNewNonEthTransactor: ZetaConnectorNewNonEthTransactor{contract: contract}, ZetaConnectorNewNonEthFilterer: ZetaConnectorNewNonEthFilterer{contract: contract}}, nil + return &ZetaConnectorNonNative{ZetaConnectorNonNativeCaller: ZetaConnectorNonNativeCaller{contract: contract}, ZetaConnectorNonNativeTransactor: ZetaConnectorNonNativeTransactor{contract: contract}, ZetaConnectorNonNativeFilterer: ZetaConnectorNonNativeFilterer{contract: contract}}, nil } -// NewZetaConnectorNewNonEthCaller creates a new read-only instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. -func NewZetaConnectorNewNonEthCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNewNonEthCaller, error) { - contract, err := bindZetaConnectorNewNonEth(address, caller, nil, nil) +// NewZetaConnectorNonNativeCaller creates a new read-only instance of ZetaConnectorNonNative, bound to a specific deployed contract. +func NewZetaConnectorNonNativeCaller(address common.Address, caller bind.ContractCaller) (*ZetaConnectorNonNativeCaller, error) { + contract, err := bindZetaConnectorNonNative(address, caller, nil, nil) if err != nil { return nil, err } - return &ZetaConnectorNewNonEthCaller{contract: contract}, nil + return &ZetaConnectorNonNativeCaller{contract: contract}, nil } -// NewZetaConnectorNewNonEthTransactor creates a new write-only instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. -func NewZetaConnectorNewNonEthTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNewNonEthTransactor, error) { - contract, err := bindZetaConnectorNewNonEth(address, nil, transactor, nil) +// NewZetaConnectorNonNativeTransactor creates a new write-only instance of ZetaConnectorNonNative, bound to a specific deployed contract. +func NewZetaConnectorNonNativeTransactor(address common.Address, transactor bind.ContractTransactor) (*ZetaConnectorNonNativeTransactor, error) { + contract, err := bindZetaConnectorNonNative(address, nil, transactor, nil) if err != nil { return nil, err } - return &ZetaConnectorNewNonEthTransactor{contract: contract}, nil + return &ZetaConnectorNonNativeTransactor{contract: contract}, nil } -// NewZetaConnectorNewNonEthFilterer creates a new log filterer instance of ZetaConnectorNewNonEth, bound to a specific deployed contract. -func NewZetaConnectorNewNonEthFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNewNonEthFilterer, error) { - contract, err := bindZetaConnectorNewNonEth(address, nil, nil, filterer) +// NewZetaConnectorNonNativeFilterer creates a new log filterer instance of ZetaConnectorNonNative, bound to a specific deployed contract. +func NewZetaConnectorNonNativeFilterer(address common.Address, filterer bind.ContractFilterer) (*ZetaConnectorNonNativeFilterer, error) { + contract, err := bindZetaConnectorNonNative(address, nil, nil, filterer) if err != nil { return nil, err } - return &ZetaConnectorNewNonEthFilterer{contract: contract}, nil + return &ZetaConnectorNonNativeFilterer{contract: contract}, nil } -// bindZetaConnectorNewNonEth binds a generic wrapper to an already deployed contract. -func bindZetaConnectorNewNonEth(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := ZetaConnectorNewNonEthMetaData.GetAbi() +// bindZetaConnectorNonNative binds a generic wrapper to an already deployed contract. +func bindZetaConnectorNonNative(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ZetaConnectorNonNativeMetaData.GetAbi() if err != nil { return nil, err } @@ -168,46 +168,46 @@ func bindZetaConnectorNewNonEth(address common.Address, caller bind.ContractCall // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthCaller.contract.Call(opts, result, method, params...) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNonNative.Contract.ZetaConnectorNonNativeCaller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthTransactor.contract.Transfer(opts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.ZetaConnectorNonNativeTransactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.ZetaConnectorNewNonEthTransactor.contract.Transact(opts, method, params...) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.ZetaConnectorNonNativeTransactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { - return _ZetaConnectorNewNonEth.Contract.contract.Call(opts, result, method, params...) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ZetaConnectorNonNative.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.contract.Transfer(opts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.contract.Transact(opts, method, params...) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.contract.Transact(opts, method, params...) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeCaller) Gateway(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ZetaConnectorNewNonEth.contract.Call(opts, &out, "gateway") + err := _ZetaConnectorNonNative.contract.Call(opts, &out, "gateway") if err != nil { return *new(common.Address), err @@ -222,23 +222,23 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) Gateway(opts *bind. // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) Gateway() (common.Address, error) { - return _ZetaConnectorNewNonEth.Contract.Gateway(&_ZetaConnectorNewNonEth.CallOpts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeSession) Gateway() (common.Address, error) { + return _ZetaConnectorNonNative.Contract.Gateway(&_ZetaConnectorNonNative.CallOpts) } // Gateway is a free data retrieval call binding the contract method 0x116191b6. // // Solidity: function gateway() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerSession) Gateway() (common.Address, error) { - return _ZetaConnectorNewNonEth.Contract.Gateway(&_ZetaConnectorNewNonEth.CallOpts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeCallerSession) Gateway() (common.Address, error) { + return _ZetaConnectorNonNative.Contract.Gateway(&_ZetaConnectorNonNative.CallOpts) } // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeCaller) ZetaToken(opts *bind.CallOpts) (common.Address, error) { var out []interface{} - err := _ZetaConnectorNewNonEth.contract.Call(opts, &out, "zetaToken") + err := _ZetaConnectorNonNative.contract.Call(opts, &out, "zetaToken") if err != nil { return *new(common.Address), err @@ -253,83 +253,83 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCaller) ZetaToken(opts *bin // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNewNonEth.Contract.ZetaToken(&_ZetaConnectorNewNonEth.CallOpts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNonNative.Contract.ZetaToken(&_ZetaConnectorNonNative.CallOpts) } // ZetaToken is a free data retrieval call binding the contract method 0x21e093b1. // // Solidity: function zetaToken() view returns(address) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthCallerSession) ZetaToken() (common.Address, error) { - return _ZetaConnectorNewNonEth.Contract.ZetaToken(&_ZetaConnectorNewNonEth.CallOpts) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeCallerSession) ZetaToken() (common.Address, error) { + return _ZetaConnectorNonNative.Contract.ZetaToken(&_ZetaConnectorNonNative.CallOpts) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.contract.Transact(opts, "receiveTokens", amount) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactor) ReceiveTokens(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNonNative.contract.Transact(opts, "receiveTokens", amount) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.ReceiveTokens(&_ZetaConnectorNewNonEth.TransactOpts, amount) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.ReceiveTokens(&_ZetaConnectorNonNative.TransactOpts, amount) } // ReceiveTokens is a paid mutator transaction binding the contract method 0x743e0c9b. // // Solidity: function receiveTokens(uint256 amount) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.ReceiveTokens(&_ZetaConnectorNewNonEth.TransactOpts, amount) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactorSession) ReceiveTokens(amount *big.Int) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.ReceiveTokens(&_ZetaConnectorNonNative.TransactOpts, amount) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.contract.Transact(opts, "withdraw", to, amount, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactor) Withdraw(opts *bind.TransactOpts, to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.contract.Transact(opts, "withdraw", to, amount, internalSendHash) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.Withdraw(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.Withdraw(&_ZetaConnectorNonNative.TransactOpts, to, amount, internalSendHash) } // Withdraw is a paid mutator transaction binding the contract method 0x106e6290. // // Solidity: function withdraw(address to, uint256 amount, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.Withdraw(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactorSession) Withdraw(to common.Address, amount *big.Int, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.Withdraw(&_ZetaConnectorNonNative.TransactOpts, to, amount, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactor) WithdrawAndCall(opts *bind.TransactOpts, to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.contract.Transact(opts, "withdrawAndCall", to, amount, data, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.WithdrawAndCall(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, data, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.WithdrawAndCall(&_ZetaConnectorNonNative.TransactOpts, to, amount, data, internalSendHash) } // WithdrawAndCall is a paid mutator transaction binding the contract method 0x5e3e9fef. // // Solidity: function withdrawAndCall(address to, uint256 amount, bytes data, bytes32 internalSendHash) returns() -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { - return _ZetaConnectorNewNonEth.Contract.WithdrawAndCall(&_ZetaConnectorNewNonEth.TransactOpts, to, amount, data, internalSendHash) +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeTransactorSession) WithdrawAndCall(to common.Address, amount *big.Int, data []byte, internalSendHash [32]byte) (*types.Transaction, error) { + return _ZetaConnectorNonNative.Contract.WithdrawAndCall(&_ZetaConnectorNonNative.TransactOpts, to, amount, data, internalSendHash) } -// ZetaConnectorNewNonEthWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNewNonEth contract. -type ZetaConnectorNewNonEthWithdrawIterator struct { - Event *ZetaConnectorNewNonEthWithdraw // Event containing the contract specifics and raw log +// ZetaConnectorNonNativeWithdrawIterator is returned from FilterWithdraw and is used to iterate over the raw logs and unpacked data for Withdraw events raised by the ZetaConnectorNonNative contract. +type ZetaConnectorNonNativeWithdrawIterator struct { + Event *ZetaConnectorNonNativeWithdraw // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -343,7 +343,7 @@ type ZetaConnectorNewNonEthWithdrawIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewNonEthWithdrawIterator) Next() bool { +func (it *ZetaConnectorNonNativeWithdrawIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -352,7 +352,7 @@ func (it *ZetaConnectorNewNonEthWithdrawIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewNonEthWithdraw) + it.Event = new(ZetaConnectorNonNativeWithdraw) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -367,7 +367,7 @@ func (it *ZetaConnectorNewNonEthWithdrawIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewNonEthWithdraw) + it.Event = new(ZetaConnectorNonNativeWithdraw) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -383,19 +383,19 @@ func (it *ZetaConnectorNewNonEthWithdrawIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewNonEthWithdrawIterator) Error() error { +func (it *ZetaConnectorNonNativeWithdrawIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ZetaConnectorNewNonEthWithdrawIterator) Close() error { +func (it *ZetaConnectorNonNativeWithdrawIterator) Close() error { it.sub.Unsubscribe() return nil } -// ZetaConnectorNewNonEthWithdraw represents a Withdraw event raised by the ZetaConnectorNewNonEth contract. -type ZetaConnectorNewNonEthWithdraw struct { +// ZetaConnectorNonNativeWithdraw represents a Withdraw event raised by the ZetaConnectorNonNative contract. +type ZetaConnectorNonNativeWithdraw struct { To common.Address Amount *big.Int Raw types.Log // Blockchain specific contextual infos @@ -404,31 +404,31 @@ type ZetaConnectorNewNonEthWithdraw struct { // FilterWithdraw is a free log retrieval operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewNonEthWithdrawIterator, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) FilterWithdraw(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNonNativeWithdrawIterator, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewNonEth.contract.FilterLogs(opts, "Withdraw", toRule) + logs, sub, err := _ZetaConnectorNonNative.contract.FilterLogs(opts, "Withdraw", toRule) if err != nil { return nil, err } - return &ZetaConnectorNewNonEthWithdrawIterator{contract: _ZetaConnectorNewNonEth.contract, event: "Withdraw", logs: logs, sub: sub}, nil + return &ZetaConnectorNonNativeWithdrawIterator{contract: _ZetaConnectorNonNative.contract, event: "Withdraw", logs: logs, sub: sub}, nil } // WatchWithdraw is a free log subscription operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewNonEthWithdraw, to []common.Address) (event.Subscription, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) WatchWithdraw(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNonNativeWithdraw, to []common.Address) (event.Subscription, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewNonEth.contract.WatchLogs(opts, "Withdraw", toRule) + logs, sub, err := _ZetaConnectorNonNative.contract.WatchLogs(opts, "Withdraw", toRule) if err != nil { return nil, err } @@ -438,8 +438,8 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdraw(opt select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewNonEthWithdraw) - if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "Withdraw", log); err != nil { + event := new(ZetaConnectorNonNativeWithdraw) + if err := _ZetaConnectorNonNative.contract.UnpackLog(event, "Withdraw", log); err != nil { return err } event.Raw = log @@ -463,18 +463,18 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdraw(opt // ParseWithdraw is a log parse operation binding the contract event 0x884edad9ce6fa2440d8a54cc123490eb96d2768479d49ff9c7366125a9424364. // // Solidity: event Withdraw(address indexed to, uint256 amount) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNewNonEthWithdraw, error) { - event := new(ZetaConnectorNewNonEthWithdraw) - if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "Withdraw", log); err != nil { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) ParseWithdraw(log types.Log) (*ZetaConnectorNonNativeWithdraw, error) { + event := new(ZetaConnectorNonNativeWithdraw) + if err := _ZetaConnectorNonNative.contract.UnpackLog(event, "Withdraw", log); err != nil { return nil, err } event.Raw = log return event, nil } -// ZetaConnectorNewNonEthWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNewNonEth contract. -type ZetaConnectorNewNonEthWithdrawAndCallIterator struct { - Event *ZetaConnectorNewNonEthWithdrawAndCall // Event containing the contract specifics and raw log +// ZetaConnectorNonNativeWithdrawAndCallIterator is returned from FilterWithdrawAndCall and is used to iterate over the raw logs and unpacked data for WithdrawAndCall events raised by the ZetaConnectorNonNative contract. +type ZetaConnectorNonNativeWithdrawAndCallIterator struct { + Event *ZetaConnectorNonNativeWithdrawAndCall // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -488,7 +488,7 @@ type ZetaConnectorNewNonEthWithdrawAndCallIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Next() bool { +func (it *ZetaConnectorNonNativeWithdrawAndCallIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -497,7 +497,7 @@ func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewNonEthWithdrawAndCall) + it.Event = new(ZetaConnectorNonNativeWithdrawAndCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -512,7 +512,7 @@ func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(ZetaConnectorNewNonEthWithdrawAndCall) + it.Event = new(ZetaConnectorNonNativeWithdrawAndCall) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -528,19 +528,19 @@ func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Error() error { +func (it *ZetaConnectorNonNativeWithdrawAndCallIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *ZetaConnectorNewNonEthWithdrawAndCallIterator) Close() error { +func (it *ZetaConnectorNonNativeWithdrawAndCallIterator) Close() error { it.sub.Unsubscribe() return nil } -// ZetaConnectorNewNonEthWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNewNonEth contract. -type ZetaConnectorNewNonEthWithdrawAndCall struct { +// ZetaConnectorNonNativeWithdrawAndCall represents a WithdrawAndCall event raised by the ZetaConnectorNonNative contract. +type ZetaConnectorNonNativeWithdrawAndCall struct { To common.Address Amount *big.Int Data []byte @@ -550,31 +550,31 @@ type ZetaConnectorNewNonEthWithdrawAndCall struct { // FilterWithdrawAndCall is a free log retrieval operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNewNonEthWithdrawAndCallIterator, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) FilterWithdrawAndCall(opts *bind.FilterOpts, to []common.Address) (*ZetaConnectorNonNativeWithdrawAndCallIterator, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewNonEth.contract.FilterLogs(opts, "WithdrawAndCall", toRule) + logs, sub, err := _ZetaConnectorNonNative.contract.FilterLogs(opts, "WithdrawAndCall", toRule) if err != nil { return nil, err } - return &ZetaConnectorNewNonEthWithdrawAndCallIterator{contract: _ZetaConnectorNewNonEth.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil + return &ZetaConnectorNonNativeWithdrawAndCallIterator{contract: _ZetaConnectorNonNative.contract, event: "WithdrawAndCall", logs: logs, sub: sub}, nil } // WatchWithdrawAndCall is a free log subscription operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNewNonEthWithdrawAndCall, to []common.Address) (event.Subscription, error) { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) WatchWithdrawAndCall(opts *bind.WatchOpts, sink chan<- *ZetaConnectorNonNativeWithdrawAndCall, to []common.Address) (event.Subscription, error) { var toRule []interface{} for _, toItem := range to { toRule = append(toRule, toItem) } - logs, sub, err := _ZetaConnectorNewNonEth.contract.WatchLogs(opts, "WithdrawAndCall", toRule) + logs, sub, err := _ZetaConnectorNonNative.contract.WatchLogs(opts, "WithdrawAndCall", toRule) if err != nil { return nil, err } @@ -584,8 +584,8 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdrawAndC select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(ZetaConnectorNewNonEthWithdrawAndCall) - if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { + event := new(ZetaConnectorNonNativeWithdrawAndCall) + if err := _ZetaConnectorNonNative.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { return err } event.Raw = log @@ -609,9 +609,9 @@ func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) WatchWithdrawAndC // ParseWithdrawAndCall is a log parse operation binding the contract event 0x7772f56296d3a5202974a45c61c9188d844ab4d6eeb18c851e4b8d5384ca6ced. // // Solidity: event WithdrawAndCall(address indexed to, uint256 amount, bytes data) -func (_ZetaConnectorNewNonEth *ZetaConnectorNewNonEthFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNewNonEthWithdrawAndCall, error) { - event := new(ZetaConnectorNewNonEthWithdrawAndCall) - if err := _ZetaConnectorNewNonEth.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { +func (_ZetaConnectorNonNative *ZetaConnectorNonNativeFilterer) ParseWithdrawAndCall(log types.Log) (*ZetaConnectorNonNativeWithdrawAndCall, error) { + event := new(ZetaConnectorNonNativeWithdrawAndCall) + if err := _ZetaConnectorNonNative.contract.UnpackLog(event, "WithdrawAndCall", log); err != nil { return nil, err } event.Raw = log diff --git a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go index 09f8a4fe..de4845d7 100644 --- a/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go +++ b/pkg/contracts/prototypes/zevm/gatewayzevm.sol/gatewayzevm.go @@ -38,8 +38,8 @@ type ZContext struct { // GatewayZEVMMetaData contains all meta data concerning the GatewayZEVM contract. var GatewayZEVMMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZetaTokenTransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", - Bin: "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", + ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Call\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"to\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"gasfee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"protocolFlatFee\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"Withdrawal\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FUNGIBLE_MODULE_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"call\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"depositAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"bytes\",\"name\":\"origin\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"chainID\",\"type\":\"uint256\"}],\"internalType\":\"structzContext\",\"name\":\"context\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"execute\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_zetaToken\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"message\",\"type\":\"bytes\"}],\"name\":\"withdrawAndCall\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"zetaToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]", + Bin: "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", } // GatewayZEVMABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go index 229c59f5..37bf4109 100644 --- a/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go +++ b/pkg/contracts/prototypes/zevm/igatewayzevm.sol/igatewayzevmerrors.go @@ -31,7 +31,7 @@ var ( // IGatewayZEVMErrorsMetaData contains all meta data concerning the IGatewayZEVMErrors contract. var IGatewayZEVMErrorsMetaData = &bind.MetaData{ - ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZetaTokenTransferFailed\",\"type\":\"error\"}]", + ABI: "[{\"inputs\":[],\"name\":\"CallerIsNotFungibleModule\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedZetaSent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"GasFeeTransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientZRC20Amount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"WithdrawalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20BurnFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZRC20TransferFailed\",\"type\":\"error\"}]", } // IGatewayZEVMErrorsABI is the input ABI used to generate the binding from. diff --git a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go index 57cbb878..31b61b3f 100644 --- a/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go +++ b/pkg/contracts/prototypes/zevm/senderzevm.sol/senderzevm.go @@ -32,7 +32,7 @@ var ( // SenderZEVMMetaData contains all meta data concerning the SenderZEVM contract. var SenderZEVMMetaData = &bind.MetaData{ ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_gateway\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"ApprovalFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"callReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"gateway\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"receiver\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"zrc20\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"str\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"flag\",\"type\":\"bool\"}],\"name\":\"withdrawAndCallReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]", - Bin: "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", + Bin: "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", } // SenderZEVMABI is the input ABI used to generate the binding from. diff --git a/test/prototypes/GatewayEVMUniswap.spec.ts b/test/prototypes/GatewayEVMUniswap.spec.ts index 6f2eab70..820c1654 100644 --- a/test/prototypes/GatewayEVMUniswap.spec.ts +++ b/test/prototypes/GatewayEVMUniswap.spec.ts @@ -59,7 +59,7 @@ describe("Uniswap Integration with GatewayEVM", function () { // Deploy contracts const Gateway = await ethers.getContractFactory("GatewayEVM"); const ERC20CustodyNew = await ethers.getContractFactory("ERC20CustodyNew"); - const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNewNonEth"); + const ZetaConnector = await ethers.getContractFactory("ZetaConnectorNonNative"); const zeta = await TestERC20.deploy("Zeta", "ZETA"); gateway = (await upgrades.deployProxy(Gateway, [tssAddress.address, zeta.address], { initializer: "initialize", diff --git a/testFoundry/GatewayEVM.t.sol b/testFoundry/GatewayEVM.t.sol index 2ac683e7..c807db09 100644 --- a/testFoundry/GatewayEVM.t.sol +++ b/testFoundry/GatewayEVM.t.sol @@ -7,7 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; +import "contracts/prototypes/evm/ZetaConnectorNonNative.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -23,7 +23,7 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; - ZetaConnectorNewNonEth zetaConnector; + ZetaConnectorNonNative zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -47,7 +47,7 @@ contract GatewayEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IReceiver )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNonNative(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); @@ -181,7 +181,7 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR GatewayEVM gateway; ERC20CustodyNew custody; - ZetaConnectorNewNonEth zetaConnector; + ZetaConnectorNonNative zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -203,7 +203,7 @@ contract GatewayEVMInboundTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IR )); gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNonNative(address(gateway), address(zeta)); gateway.setCustody(address(custody)); gateway.setConnector(address(zetaConnector)); diff --git a/testFoundry/GatewayEVMUpgrade.t.sol b/testFoundry/GatewayEVMUpgrade.t.sol index 6960c90c..24d87587 100644 --- a/testFoundry/GatewayEVMUpgrade.t.sol +++ b/testFoundry/GatewayEVMUpgrade.t.sol @@ -8,7 +8,7 @@ import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/GatewayEVMUpgradeTest.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; +import "contracts/prototypes/evm/ZetaConnectorNonNative.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; @@ -25,7 +25,7 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents GatewayEVM gateway; ReceiverEVM receiver; ERC20CustodyNew custody; - ZetaConnectorNewNonEth zetaConnector; + ZetaConnectorNonNative zetaConnector; TestERC20 token; TestERC20 zeta; address owner; @@ -47,7 +47,7 @@ contract GatewayEVMUUPSUpgradeTest is Test, IGatewayEVMErrors, IGatewayEVMEvents gateway = GatewayEVM(proxy); custody = new ERC20CustodyNew(address(gateway)); - zetaConnector = new ZetaConnectorNewNonEth(address(gateway), address(zeta)); + zetaConnector = new ZetaConnectorNonNative(address(gateway), address(zeta)); receiver = new ReceiverEVM(); gateway.setCustody(address(custody)); diff --git a/testFoundry/GatewayEVMZEVM.t.sol b/testFoundry/GatewayEVMZEVM.t.sol index a3d94c93..25dcaa0d 100644 --- a/testFoundry/GatewayEVMZEVM.t.sol +++ b/testFoundry/GatewayEVMZEVM.t.sol @@ -7,7 +7,7 @@ import "forge-std/Vm.sol"; import "contracts/prototypes/evm/GatewayEVM.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; import "contracts/prototypes/evm/ERC20CustodyNew.sol"; -import "contracts/prototypes/evm/ZetaConnectorNewNonEth.sol"; +import "contracts/prototypes/evm/ZetaConnectorNonNative.sol"; import "contracts/prototypes/evm/TestERC20.sol"; import "contracts/prototypes/evm/ReceiverEVM.sol"; @@ -31,7 +31,7 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate address proxyEVM; GatewayEVM gatewayEVM; ERC20CustodyNew custody; - ZetaConnectorNewNonEth zetaConnector; + ZetaConnectorNonNative zetaConnector; TestERC20 token; TestERC20 zeta; ReceiverEVM receiverEVM; @@ -63,7 +63,7 @@ contract GatewayEVMZEVMTest is Test, IGatewayEVMErrors, IGatewayEVMEvents, IGate )); gatewayEVM = GatewayEVM(proxyEVM); custody = new ERC20CustodyNew(address(gatewayEVM)); - zetaConnector = new ZetaConnectorNewNonEth(address(gatewayEVM), address(zeta)); + zetaConnector = new ZetaConnectorNonNative(address(gatewayEVM), address(zeta)); gatewayEVM.setCustody(address(custody)); gatewayEVM.setConnector(address(zetaConnector)); diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNative.ts similarity index 98% rename from typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts rename to typechain-types/contracts/prototypes/evm/ZetaConnectorNative.ts index 8cc41d88..afe99d1d 100644 --- a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewEth.ts +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNative.ts @@ -27,7 +27,7 @@ import type { PromiseOrValue, } from "../../../common"; -export interface ZetaConnectorNewEthInterface extends utils.Interface { +export interface ZetaConnectorNativeInterface extends utils.Interface { functions: { "gateway()": FunctionFragment; "receiveTokens(uint256)": FunctionFragment; @@ -113,12 +113,12 @@ export type WithdrawAndCallEvent = TypedEvent< export type WithdrawAndCallEventFilter = TypedEventFilter; -export interface ZetaConnectorNewEth extends BaseContract { +export interface ZetaConnectorNative extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; - interface: ZetaConnectorNewEthInterface; + interface: ZetaConnectorNativeInterface; queryFilter( event: TypedEventFilter, diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts deleted file mode 100644 index 97b9e359..00000000 --- a/typechain-types/contracts/prototypes/evm/ZetaConnectorNew.ts +++ /dev/null @@ -1,241 +0,0 @@ -/* Autogenerated file. Do not edit manually. */ -/* tslint:disable */ -/* eslint-disable */ -import type { - BaseContract, - BigNumber, - BigNumberish, - BytesLike, - CallOverrides, - ContractTransaction, - Overrides, - PopulatedTransaction, - Signer, - utils, -} from "ethers"; -import type { - FunctionFragment, - Result, - EventFragment, -} from "@ethersproject/abi"; -import type { Listener, Provider } from "@ethersproject/providers"; -import type { - TypedEventFilter, - TypedEvent, - TypedListener, - OnEvent, - PromiseOrValue, -} from "../../../common"; - -export interface ZetaConnectorNewInterface extends utils.Interface { - functions: { - "gateway()": FunctionFragment; - "withdraw(address,uint256)": FunctionFragment; - "withdrawAndCall(address,uint256,bytes)": FunctionFragment; - "zetaToken()": FunctionFragment; - }; - - getFunction( - nameOrSignatureOrTopic: - | "gateway" - | "withdraw" - | "withdrawAndCall" - | "zetaToken" - ): FunctionFragment; - - encodeFunctionData(functionFragment: "gateway", values?: undefined): string; - encodeFunctionData( - functionFragment: "withdraw", - values: [PromiseOrValue, PromiseOrValue] - ): string; - encodeFunctionData( - functionFragment: "withdrawAndCall", - values: [ - PromiseOrValue, - PromiseOrValue, - PromiseOrValue - ] - ): string; - encodeFunctionData(functionFragment: "zetaToken", values?: undefined): string; - - decodeFunctionResult(functionFragment: "gateway", data: BytesLike): Result; - decodeFunctionResult(functionFragment: "withdraw", data: BytesLike): Result; - decodeFunctionResult( - functionFragment: "withdrawAndCall", - data: BytesLike - ): Result; - decodeFunctionResult(functionFragment: "zetaToken", data: BytesLike): Result; - - events: { - "Withdraw(address,uint256)": EventFragment; - "WithdrawAndCall(address,uint256,bytes)": EventFragment; - }; - - getEvent(nameOrSignatureOrTopic: "Withdraw"): EventFragment; - getEvent(nameOrSignatureOrTopic: "WithdrawAndCall"): EventFragment; -} - -export interface WithdrawEventObject { - to: string; - amount: BigNumber; -} -export type WithdrawEvent = TypedEvent< - [string, BigNumber], - WithdrawEventObject ->; - -export type WithdrawEventFilter = TypedEventFilter; - -export interface WithdrawAndCallEventObject { - to: string; - amount: BigNumber; - data: string; -} -export type WithdrawAndCallEvent = TypedEvent< - [string, BigNumber, string], - WithdrawAndCallEventObject ->; - -export type WithdrawAndCallEventFilter = TypedEventFilter; - -export interface ZetaConnectorNew extends BaseContract { - connect(signerOrProvider: Signer | Provider | string): this; - attach(addressOrName: string): this; - deployed(): Promise; - - interface: ZetaConnectorNewInterface; - - queryFilter( - event: TypedEventFilter, - fromBlockOrBlockhash?: string | number | undefined, - toBlock?: string | number | undefined - ): Promise>; - - listeners( - eventFilter?: TypedEventFilter - ): Array>; - listeners(eventName?: string): Array; - removeAllListeners( - eventFilter: TypedEventFilter - ): this; - removeAllListeners(eventName?: string): this; - off: OnEvent; - on: OnEvent; - once: OnEvent; - removeListener: OnEvent; - - functions: { - gateway(overrides?: CallOverrides): Promise<[string]>; - - withdraw( - to: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - withdrawAndCall( - to: PromiseOrValue, - amount: PromiseOrValue, - data: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - zetaToken(overrides?: CallOverrides): Promise<[string]>; - }; - - gateway(overrides?: CallOverrides): Promise; - - withdraw( - to: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - withdrawAndCall( - to: PromiseOrValue, - amount: PromiseOrValue, - data: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - zetaToken(overrides?: CallOverrides): Promise; - - callStatic: { - gateway(overrides?: CallOverrides): Promise; - - withdraw( - to: PromiseOrValue, - amount: PromiseOrValue, - overrides?: CallOverrides - ): Promise; - - withdrawAndCall( - to: PromiseOrValue, - amount: PromiseOrValue, - data: PromiseOrValue, - overrides?: CallOverrides - ): Promise; - - zetaToken(overrides?: CallOverrides): Promise; - }; - - filters: { - "Withdraw(address,uint256)"( - to?: PromiseOrValue | null, - amount?: null - ): WithdrawEventFilter; - Withdraw( - to?: PromiseOrValue | null, - amount?: null - ): WithdrawEventFilter; - - "WithdrawAndCall(address,uint256,bytes)"( - to?: PromiseOrValue | null, - amount?: null, - data?: null - ): WithdrawAndCallEventFilter; - WithdrawAndCall( - to?: PromiseOrValue | null, - amount?: null, - data?: null - ): WithdrawAndCallEventFilter; - }; - - estimateGas: { - gateway(overrides?: CallOverrides): Promise; - - withdraw( - to: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - withdrawAndCall( - to: PromiseOrValue, - amount: PromiseOrValue, - data: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - zetaToken(overrides?: CallOverrides): Promise; - }; - - populateTransaction: { - gateway(overrides?: CallOverrides): Promise; - - withdraw( - to: PromiseOrValue, - amount: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - withdrawAndCall( - to: PromiseOrValue, - amount: PromiseOrValue, - data: PromiseOrValue, - overrides?: Overrides & { from?: PromiseOrValue } - ): Promise; - - zetaToken(overrides?: CallOverrides): Promise; - }; -} diff --git a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts b/typechain-types/contracts/prototypes/evm/ZetaConnectorNonNative.ts similarity index 97% rename from typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts rename to typechain-types/contracts/prototypes/evm/ZetaConnectorNonNative.ts index 2b128dc1..426bfefe 100644 --- a/typechain-types/contracts/prototypes/evm/ZetaConnectorNewNonEth.ts +++ b/typechain-types/contracts/prototypes/evm/ZetaConnectorNonNative.ts @@ -27,7 +27,7 @@ import type { PromiseOrValue, } from "../../../common"; -export interface ZetaConnectorNewNonEthInterface extends utils.Interface { +export interface ZetaConnectorNonNativeInterface extends utils.Interface { functions: { "gateway()": FunctionFragment; "receiveTokens(uint256)": FunctionFragment; @@ -113,12 +113,12 @@ export type WithdrawAndCallEvent = TypedEvent< export type WithdrawAndCallEventFilter = TypedEventFilter; -export interface ZetaConnectorNewNonEth extends BaseContract { +export interface ZetaConnectorNonNative extends BaseContract { connect(signerOrProvider: Signer | Provider | string): this; attach(addressOrName: string): this; deployed(): Promise; - interface: ZetaConnectorNewNonEthInterface; + interface: ZetaConnectorNonNativeInterface; queryFilter( event: TypedEventFilter, diff --git a/typechain-types/contracts/prototypes/evm/index.ts b/typechain-types/contracts/prototypes/evm/index.ts index 4a445f5d..a75a6c24 100644 --- a/typechain-types/contracts/prototypes/evm/index.ts +++ b/typechain-types/contracts/prototypes/evm/index.ts @@ -11,6 +11,6 @@ export type { GatewayEVMUpgradeTest } from "./GatewayEVMUpgradeTest"; export type { IZetaNonEthNew } from "./IZetaNonEthNew"; export type { ReceiverEVM } from "./ReceiverEVM"; export type { TestERC20 } from "./TestERC20"; +export type { ZetaConnectorNative } from "./ZetaConnectorNative"; export type { ZetaConnectorNewBase } from "./ZetaConnectorNewBase"; -export type { ZetaConnectorNewEth } from "./ZetaConnectorNewEth"; -export type { ZetaConnectorNewNonEth } from "./ZetaConnectorNewNonEth"; +export type { ZetaConnectorNonNative } from "./ZetaConnectorNonNative"; diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNative__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNative__factory.ts new file mode 100644 index 00000000..3aeb24ba --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNative__factory.ts @@ -0,0 +1,226 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZetaConnectorNative, + ZetaConnectorNativeInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNative"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + { + internalType: "address", + name: "_zetaToken", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "receiveTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zetaToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZetaConnectorNativeConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZetaConnectorNativeConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZetaConnectorNative__factory extends ContractFactory { + constructor(...args: ZetaConnectorNativeConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + _gateway, + _zetaToken, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, _zetaToken, overrides || {}); + } + override attach(address: string): ZetaConnectorNative { + return super.attach(address) as ZetaConnectorNative; + } + override connect(signer: Signer): ZetaConnectorNative__factory { + return super.connect(signer) as ZetaConnectorNative__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZetaConnectorNativeInterface { + return new utils.Interface(_abi) as ZetaConnectorNativeInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNative { + return new Contract(address, _abi, signerOrProvider) as ZetaConnectorNative; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNonNative__factory.ts b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNonNative__factory.ts new file mode 100644 index 00000000..f64b2993 --- /dev/null +++ b/typechain-types/factories/contracts/prototypes/evm/ZetaConnectorNonNative__factory.ts @@ -0,0 +1,230 @@ +/* Autogenerated file. Do not edit manually. */ +/* tslint:disable */ +/* eslint-disable */ +import { Signer, utils, Contract, ContractFactory, Overrides } from "ethers"; +import type { Provider, TransactionRequest } from "@ethersproject/providers"; +import type { PromiseOrValue } from "../../../../common"; +import type { + ZetaConnectorNonNative, + ZetaConnectorNonNativeInterface, +} from "../../../../contracts/prototypes/evm/ZetaConnectorNonNative"; + +const _abi = [ + { + inputs: [ + { + internalType: "address", + name: "_gateway", + type: "address", + }, + { + internalType: "address", + name: "_zetaToken", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "ZeroAddress", + type: "error", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "Withdraw", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "address", + name: "to", + type: "address", + }, + { + indexed: false, + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + indexed: false, + internalType: "bytes", + name: "data", + type: "bytes", + }, + ], + name: "WithdrawAndCall", + type: "event", + }, + { + inputs: [], + name: "gateway", + outputs: [ + { + internalType: "contract IGatewayEVM", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + ], + name: "receiveTokens", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdraw", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "to", + type: "address", + }, + { + internalType: "uint256", + name: "amount", + type: "uint256", + }, + { + internalType: "bytes", + name: "data", + type: "bytes", + }, + { + internalType: "bytes32", + name: "internalSendHash", + type: "bytes32", + }, + ], + name: "withdrawAndCall", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "zetaToken", + outputs: [ + { + internalType: "address", + name: "", + type: "address", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; + +const _bytecode = + "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"; + +type ZetaConnectorNonNativeConstructorParams = + | [signer?: Signer] + | ConstructorParameters; + +const isSuperArgs = ( + xs: ZetaConnectorNonNativeConstructorParams +): xs is ConstructorParameters => xs.length > 1; + +export class ZetaConnectorNonNative__factory extends ContractFactory { + constructor(...args: ZetaConnectorNonNativeConstructorParams) { + if (isSuperArgs(args)) { + super(...args); + } else { + super(_abi, _bytecode, args[0]); + } + } + + override deploy( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): Promise { + return super.deploy( + _gateway, + _zetaToken, + overrides || {} + ) as Promise; + } + override getDeployTransaction( + _gateway: PromiseOrValue, + _zetaToken: PromiseOrValue, + overrides?: Overrides & { from?: PromiseOrValue } + ): TransactionRequest { + return super.getDeployTransaction(_gateway, _zetaToken, overrides || {}); + } + override attach(address: string): ZetaConnectorNonNative { + return super.attach(address) as ZetaConnectorNonNative; + } + override connect(signer: Signer): ZetaConnectorNonNative__factory { + return super.connect(signer) as ZetaConnectorNonNative__factory; + } + + static readonly bytecode = _bytecode; + static readonly abi = _abi; + static createInterface(): ZetaConnectorNonNativeInterface { + return new utils.Interface(_abi) as ZetaConnectorNonNativeInterface; + } + static connect( + address: string, + signerOrProvider: Signer | Provider + ): ZetaConnectorNonNative { + return new Contract( + address, + _abi, + signerOrProvider + ) as ZetaConnectorNonNative; + } +} diff --git a/typechain-types/factories/contracts/prototypes/evm/index.ts b/typechain-types/factories/contracts/prototypes/evm/index.ts index 788c8c3a..b6965aa9 100644 --- a/typechain-types/factories/contracts/prototypes/evm/index.ts +++ b/typechain-types/factories/contracts/prototypes/evm/index.ts @@ -9,6 +9,6 @@ export { GatewayEVMUpgradeTest__factory } from "./GatewayEVMUpgradeTest__factory export { IZetaNonEthNew__factory } from "./IZetaNonEthNew__factory"; export { ReceiverEVM__factory } from "./ReceiverEVM__factory"; export { TestERC20__factory } from "./TestERC20__factory"; +export { ZetaConnectorNative__factory } from "./ZetaConnectorNative__factory"; export { ZetaConnectorNewBase__factory } from "./ZetaConnectorNewBase__factory"; -export { ZetaConnectorNewEth__factory } from "./ZetaConnectorNewEth__factory"; -export { ZetaConnectorNewNonEth__factory } from "./ZetaConnectorNewNonEth__factory"; +export { ZetaConnectorNonNative__factory } from "./ZetaConnectorNonNative__factory"; diff --git a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts index bb6b2758..15f75984 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/GatewayZEVM__factory.ts @@ -57,7 +57,7 @@ const _abi = [ }, { inputs: [], - name: "ZetaTokenTransferFailed", + name: "ZeroAddress", type: "error", }, { @@ -598,7 +598,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "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"; type GatewayZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts index 410b76b8..bde7160e 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVMErrors__factory.ts @@ -50,11 +50,6 @@ const _abi = [ name: "ZRC20TransferFailed", type: "error", }, - { - inputs: [], - name: "ZetaTokenTransferFailed", - type: "error", - }, ] as const; export class IGatewayZEVMErrors__factory { diff --git a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts index c05c5587..e559458b 100644 --- a/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts +++ b/typechain-types/factories/contracts/prototypes/zevm/SenderZEVM__factory.ts @@ -108,7 +108,7 @@ const _abi = [ ] as const; const _bytecode = - "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"; + "0x608060405234801561001057600080fd5b50604051610bcd380380610bcd8339818101604052810190610032919061008d565b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050610108565b600081519050610087816100f1565b92915050565b6000602082840312156100a3576100a26100ec565b5b60006100b184828501610078565b91505092915050565b60006100c5826100cc565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600080fd5b6100fa816100ba565b811461010557600080fd5b50565b610ab6806101176000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c80630abd890514610046578063116191b614610062578063a0a1730b14610080575b600080fd5b610060600480360381019061005b91906105fd565b61009c565b005b61006a6102af565b6040516100779190610761565b60405180910390f35b61009a6004803603810190610095919061055e565b6102d3565b005b60008383836040516024016100b39392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505090508473ffffffffffffffffffffffffffffffffffffffff1663095ea7b360008054906101000a900473ffffffffffffffffffffffffffffffffffffffff16886040518363ffffffff1660e01b815260040161018d92919061077c565b602060405180830381600087803b1580156101a757600080fd5b505af11580156101bb573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906101df9190610531565b610215576040517f8164f84200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16637993c1e0888888856040518563ffffffff1660e01b815260040161027494939291906107dc565b600060405180830381600087803b15801561028e57600080fd5b505af11580156102a2573d6000803e3d6000fd5b5050505050505050505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008383836040516024016102ea9392919061082f565b6040516020818303038152906040527fe04d4f97000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff8381831617835250505050905060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16630ac7c44c86836040518363ffffffff1660e01b81526004016103c49291906107a5565b600060405180830381600087803b1580156103de57600080fd5b505af11580156103f2573d6000803e3d6000fd5b505050505050505050565b600061041061040b84610892565b61086d565b90508281526020810184848401111561042c5761042b610a1b565b5b610437848285610974565b509392505050565b600061045261044d846108c3565b61086d565b90508281526020810184848401111561046e5761046d610a1b565b5b610479848285610974565b509392505050565b60008135905061049081610a3b565b92915050565b6000813590506104a581610a52565b92915050565b6000815190506104ba81610a52565b92915050565b600082601f8301126104d5576104d4610a16565b5b81356104e58482602086016103fd565b91505092915050565b600082601f83011261050357610502610a16565b5b813561051384826020860161043f565b91505092915050565b60008135905061052b81610a69565b92915050565b60006020828403121561054757610546610a25565b5b6000610555848285016104ab565b91505092915050565b6000806000806080858703121561057857610577610a25565b5b600085013567ffffffffffffffff81111561059657610595610a20565b5b6105a2878288016104c0565b945050602085013567ffffffffffffffff8111156105c3576105c2610a20565b5b6105cf878288016104ee565b93505060406105e08782880161051c565b92505060606105f187828801610496565b91505092959194509250565b60008060008060008060c0878903121561061a57610619610a25565b5b600087013567ffffffffffffffff81111561063857610637610a20565b5b61064489828a016104c0565b965050602061065589828a0161051c565b955050604061066689828a01610481565b945050606087013567ffffffffffffffff81111561068757610686610a20565b5b61069389828a016104ee565b93505060806106a489828a0161051c565b92505060a06106b589828a01610496565b9150509295509295509295565b6106cb8161092c565b82525050565b6106da8161093e565b82525050565b60006106eb826108f4565b6106f5818561090a565b9350610705818560208601610983565b61070e81610a2a565b840191505092915050565b6000610724826108ff565b61072e818561091b565b935061073e818560208601610983565b61074781610a2a565b840191505092915050565b61075b8161096a565b82525050565b600060208201905061077660008301846106c2565b92915050565b600060408201905061079160008301856106c2565b61079e6020830184610752565b9392505050565b600060408201905081810360008301526107bf81856106e0565b905081810360208301526107d381846106e0565b90509392505050565b600060808201905081810360008301526107f681876106e0565b90506108056020830186610752565b61081260408301856106c2565b818103606083015261082481846106e0565b905095945050505050565b600060608201905081810360008301526108498186610719565b90506108586020830185610752565b61086560408301846106d1565b949350505050565b6000610877610888565b905061088382826109b6565b919050565b6000604051905090565b600067ffffffffffffffff8211156108ad576108ac6109e7565b5b6108b682610a2a565b9050602081019050919050565b600067ffffffffffffffff8211156108de576108dd6109e7565b5b6108e782610a2a565b9050602081019050919050565b600081519050919050565b600081519050919050565b600082825260208201905092915050565b600082825260208201905092915050565b60006109378261094a565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b82818337600083830152505050565b60005b838110156109a1578082015181840152602081019050610986565b838111156109b0576000848401525b50505050565b6109bf82610a2a565b810181811067ffffffffffffffff821117156109de576109dd6109e7565b5b80604052505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b610a448161092c565b8114610a4f57600080fd5b50565b610a5b8161093e565b8114610a6657600080fd5b50565b610a728161096a565b8114610a7d57600080fd5b5056fea264697066735822122049d58736f7b9ff3ce3cfc77aac6ccdb9e3ae6b124553d5128891d85347cf779864736f6c63430008070033"; type SenderZEVMConstructorParams = | [signer?: Signer] diff --git a/typechain-types/hardhat.d.ts b/typechain-types/hardhat.d.ts index 5697c0ed..769986ad 100644 --- a/typechain-types/hardhat.d.ts +++ b/typechain-types/hardhat.d.ts @@ -373,17 +373,17 @@ declare module "hardhat/types/runtime" { signerOrOptions?: ethers.Signer | FactoryOptions ): Promise; getContractFactory( - name: "ZetaConnectorNewBase", + name: "ZetaConnectorNative", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( - name: "ZetaConnectorNewEth", + name: "ZetaConnectorNewBase", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( - name: "ZetaConnectorNewNonEth", + name: "ZetaConnectorNonNative", signerOrOptions?: ethers.Signer | FactoryOptions - ): Promise; + ): Promise; getContractFactory( name: "GatewayZEVM", signerOrOptions?: ethers.Signer | FactoryOptions @@ -936,20 +936,20 @@ declare module "hardhat/types/runtime" { signer?: ethers.Signer ): Promise; getContractAt( - name: "ZetaConnectorNewBase", + name: "ZetaConnectorNative", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "ZetaConnectorNewEth", + name: "ZetaConnectorNewBase", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( - name: "ZetaConnectorNewNonEth", + name: "ZetaConnectorNonNative", address: string, signer?: ethers.Signer - ): Promise; + ): Promise; getContractAt( name: "GatewayZEVM", address: string, diff --git a/typechain-types/index.ts b/typechain-types/index.ts index f472d97e..08e982cc 100644 --- a/typechain-types/index.ts +++ b/typechain-types/index.ts @@ -176,12 +176,12 @@ export type { ReceiverEVM } from "./contracts/prototypes/evm/ReceiverEVM"; export { ReceiverEVM__factory } from "./factories/contracts/prototypes/evm/ReceiverEVM__factory"; export type { TestERC20 } from "./contracts/prototypes/evm/TestERC20"; export { TestERC20__factory } from "./factories/contracts/prototypes/evm/TestERC20__factory"; +export type { ZetaConnectorNative } from "./contracts/prototypes/evm/ZetaConnectorNative"; +export { ZetaConnectorNative__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNative__factory"; export type { ZetaConnectorNewBase } from "./contracts/prototypes/evm/ZetaConnectorNewBase"; export { ZetaConnectorNewBase__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewBase__factory"; -export type { ZetaConnectorNewEth } from "./contracts/prototypes/evm/ZetaConnectorNewEth"; -export { ZetaConnectorNewEth__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewEth__factory"; -export type { ZetaConnectorNewNonEth } from "./contracts/prototypes/evm/ZetaConnectorNewNonEth"; -export { ZetaConnectorNewNonEth__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNewNonEth__factory"; +export type { ZetaConnectorNonNative } from "./contracts/prototypes/evm/ZetaConnectorNonNative"; +export { ZetaConnectorNonNative__factory } from "./factories/contracts/prototypes/evm/ZetaConnectorNonNative__factory"; export type { GatewayZEVM } from "./contracts/prototypes/zevm/GatewayZEVM"; export { GatewayZEVM__factory } from "./factories/contracts/prototypes/zevm/GatewayZEVM__factory"; export type { IGatewayZEVM } from "./contracts/prototypes/zevm/IGatewayZEVM.sol/IGatewayZEVM";